'Weak Dependency Graph [60.0]'
------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(V)) -> mark(isQid(V))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(__(X1, X2)) -> __(active(X1), X2)
, active(__(X1, X2)) -> __(X1, active(X2))
, active(and(X1, X2)) -> and(active(X1), X2)
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, and(mark(X1), X2) -> mark(and(X1, X2))
, proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(nil()) -> ok(nil())
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(tt()) -> ok(tt())
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isNePal(ok(X)) -> ok(isNePal(X))
, isPal(ok(X)) -> ok(isPal(X))
, top(mark(X)) -> top(proper(X))
, top(ok(X)) -> top(active(X))}
Details:
We have computed the following set of weak (innermost) dependency pairs:
{ active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z)))
, active^#(__(X, nil())) -> c_1()
, active^#(__(nil(), X)) -> c_2()
, active^#(and(tt(), X)) -> c_3()
, active^#(isList(V)) -> c_4(isNeList^#(V))
, active^#(isList(nil())) -> c_5()
, active^#(isList(__(V1, V2))) ->
c_6(and^#(isList(V1), isList(V2)))
, active^#(isNeList(V)) -> c_7(isQid^#(V))
, active^#(isNeList(__(V1, V2))) ->
c_8(and^#(isList(V1), isNeList(V2)))
, active^#(isNeList(__(V1, V2))) ->
c_9(and^#(isNeList(V1), isList(V2)))
, active^#(isNePal(V)) -> c_10(isQid^#(V))
, active^#(isNePal(__(I, __(P, I)))) ->
c_11(and^#(isQid(I), isPal(P)))
, active^#(isPal(V)) -> c_12(isNePal^#(V))
, active^#(isPal(nil())) -> c_13()
, active^#(isQid(a())) -> c_14()
, active^#(isQid(e())) -> c_15()
, active^#(isQid(i())) -> c_16()
, active^#(isQid(o())) -> c_17()
, active^#(isQid(u())) -> c_18()
, active^#(__(X1, X2)) -> c_19(__^#(active(X1), X2))
, active^#(__(X1, X2)) -> c_20(__^#(X1, active(X2)))
, active^#(and(X1, X2)) -> c_21(and^#(active(X1), X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))
, __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))
, proper^#(__(X1, X2)) -> c_25(__^#(proper(X1), proper(X2)))
, proper^#(nil()) -> c_26()
, proper^#(and(X1, X2)) -> c_27(and^#(proper(X1), proper(X2)))
, proper^#(tt()) -> c_28()
, proper^#(isList(X)) -> c_29(isList^#(proper(X)))
, proper^#(isNeList(X)) -> c_30(isNeList^#(proper(X)))
, proper^#(isQid(X)) -> c_31(isQid^#(proper(X)))
, proper^#(isNePal(X)) -> c_32(isNePal^#(proper(X)))
, proper^#(isPal(X)) -> c_33(isPal^#(proper(X)))
, proper^#(a()) -> c_34()
, proper^#(e()) -> c_35()
, proper^#(i()) -> c_36()
, proper^#(o()) -> c_37()
, proper^#(u()) -> c_38()
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))
, and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))
, isList^#(ok(X)) -> c_41(isList^#(X))
, isNeList^#(ok(X)) -> c_42(isNeList^#(X))
, isQid^#(ok(X)) -> c_43(isQid^#(X))
, isNePal^#(ok(X)) -> c_44(isNePal^#(X))
, isPal^#(ok(X)) -> c_45(isPal^#(X))
, top^#(mark(X)) -> c_46(top^#(proper(X)))
, top^#(ok(X)) -> c_47(top^#(active(X)))}
The usable rules are:
{ active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(V)) -> mark(isQid(V))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(__(X1, X2)) -> __(active(X1), X2)
, active(__(X1, X2)) -> __(X1, active(X2))
, active(and(X1, X2)) -> and(active(X1), X2)
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(nil()) -> ok(nil())
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(tt()) -> ok(tt())
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
The estimated dependency graph contains the following edges:
{active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z)))}
==> {__^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))}
{active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z)))}
==> {__^#(X1, mark(X2)) -> c_23(__^#(X1, X2))}
{active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z)))}
==> {__^#(mark(X1), X2) -> c_22(__^#(X1, X2))}
{active^#(isList(V)) -> c_4(isNeList^#(V))}
==> {isNeList^#(ok(X)) -> c_42(isNeList^#(X))}
{active^#(isList(__(V1, V2))) ->
c_6(and^#(isList(V1), isList(V2)))}
==> {and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))}
{active^#(isList(__(V1, V2))) ->
c_6(and^#(isList(V1), isList(V2)))}
==> {and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
{active^#(isNeList(V)) -> c_7(isQid^#(V))}
==> {isQid^#(ok(X)) -> c_43(isQid^#(X))}
{active^#(isNeList(__(V1, V2))) ->
c_8(and^#(isList(V1), isNeList(V2)))}
==> {and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))}
{active^#(isNeList(__(V1, V2))) ->
c_8(and^#(isList(V1), isNeList(V2)))}
==> {and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
{active^#(isNeList(__(V1, V2))) ->
c_9(and^#(isNeList(V1), isList(V2)))}
==> {and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))}
{active^#(isNeList(__(V1, V2))) ->
c_9(and^#(isNeList(V1), isList(V2)))}
==> {and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
{active^#(isNePal(V)) -> c_10(isQid^#(V))}
==> {isQid^#(ok(X)) -> c_43(isQid^#(X))}
{active^#(isNePal(__(I, __(P, I)))) ->
c_11(and^#(isQid(I), isPal(P)))}
==> {and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))}
{active^#(isNePal(__(I, __(P, I)))) ->
c_11(and^#(isQid(I), isPal(P)))}
==> {and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
{active^#(isPal(V)) -> c_12(isNePal^#(V))}
==> {isNePal^#(ok(X)) -> c_44(isNePal^#(X))}
{active^#(__(X1, X2)) -> c_19(__^#(active(X1), X2))}
==> {__^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))}
{active^#(__(X1, X2)) -> c_19(__^#(active(X1), X2))}
==> {__^#(X1, mark(X2)) -> c_23(__^#(X1, X2))}
{active^#(__(X1, X2)) -> c_19(__^#(active(X1), X2))}
==> {__^#(mark(X1), X2) -> c_22(__^#(X1, X2))}
{active^#(__(X1, X2)) -> c_20(__^#(X1, active(X2)))}
==> {__^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))}
{active^#(__(X1, X2)) -> c_20(__^#(X1, active(X2)))}
==> {__^#(X1, mark(X2)) -> c_23(__^#(X1, X2))}
{active^#(__(X1, X2)) -> c_20(__^#(X1, active(X2)))}
==> {__^#(mark(X1), X2) -> c_22(__^#(X1, X2))}
{active^#(and(X1, X2)) -> c_21(and^#(active(X1), X2))}
==> {and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))}
{active^#(and(X1, X2)) -> c_21(and^#(active(X1), X2))}
==> {and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
{__^#(mark(X1), X2) -> c_22(__^#(X1, X2))}
==> {__^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))}
{__^#(mark(X1), X2) -> c_22(__^#(X1, X2))}
==> {__^#(X1, mark(X2)) -> c_23(__^#(X1, X2))}
{__^#(mark(X1), X2) -> c_22(__^#(X1, X2))}
==> {__^#(mark(X1), X2) -> c_22(__^#(X1, X2))}
{__^#(X1, mark(X2)) -> c_23(__^#(X1, X2))}
==> {__^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))}
{__^#(X1, mark(X2)) -> c_23(__^#(X1, X2))}
==> {__^#(X1, mark(X2)) -> c_23(__^#(X1, X2))}
{__^#(X1, mark(X2)) -> c_23(__^#(X1, X2))}
==> {__^#(mark(X1), X2) -> c_22(__^#(X1, X2))}
{and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
==> {and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))}
{and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
==> {and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
{proper^#(__(X1, X2)) -> c_25(__^#(proper(X1), proper(X2)))}
==> {__^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))}
{proper^#(__(X1, X2)) -> c_25(__^#(proper(X1), proper(X2)))}
==> {__^#(X1, mark(X2)) -> c_23(__^#(X1, X2))}
{proper^#(__(X1, X2)) -> c_25(__^#(proper(X1), proper(X2)))}
==> {__^#(mark(X1), X2) -> c_22(__^#(X1, X2))}
{proper^#(and(X1, X2)) -> c_27(and^#(proper(X1), proper(X2)))}
==> {and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))}
{proper^#(and(X1, X2)) -> c_27(and^#(proper(X1), proper(X2)))}
==> {and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
{proper^#(isList(X)) -> c_29(isList^#(proper(X)))}
==> {isList^#(ok(X)) -> c_41(isList^#(X))}
{proper^#(isNeList(X)) -> c_30(isNeList^#(proper(X)))}
==> {isNeList^#(ok(X)) -> c_42(isNeList^#(X))}
{proper^#(isQid(X)) -> c_31(isQid^#(proper(X)))}
==> {isQid^#(ok(X)) -> c_43(isQid^#(X))}
{proper^#(isNePal(X)) -> c_32(isNePal^#(proper(X)))}
==> {isNePal^#(ok(X)) -> c_44(isNePal^#(X))}
{proper^#(isPal(X)) -> c_33(isPal^#(proper(X)))}
==> {isPal^#(ok(X)) -> c_45(isPal^#(X))}
{__^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))}
==> {__^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))}
{__^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))}
==> {__^#(X1, mark(X2)) -> c_23(__^#(X1, X2))}
{__^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))}
==> {__^#(mark(X1), X2) -> c_22(__^#(X1, X2))}
{and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))}
==> {and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))}
{and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))}
==> {and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
{isList^#(ok(X)) -> c_41(isList^#(X))}
==> {isList^#(ok(X)) -> c_41(isList^#(X))}
{isNeList^#(ok(X)) -> c_42(isNeList^#(X))}
==> {isNeList^#(ok(X)) -> c_42(isNeList^#(X))}
{isQid^#(ok(X)) -> c_43(isQid^#(X))}
==> {isQid^#(ok(X)) -> c_43(isQid^#(X))}
{isNePal^#(ok(X)) -> c_44(isNePal^#(X))}
==> {isNePal^#(ok(X)) -> c_44(isNePal^#(X))}
{isPal^#(ok(X)) -> c_45(isPal^#(X))}
==> {isPal^#(ok(X)) -> c_45(isPal^#(X))}
{top^#(mark(X)) -> c_46(top^#(proper(X)))}
==> {top^#(ok(X)) -> c_47(top^#(active(X)))}
{top^#(mark(X)) -> c_46(top^#(proper(X)))}
==> {top^#(mark(X)) -> c_46(top^#(proper(X)))}
{top^#(ok(X)) -> c_47(top^#(active(X)))}
==> {top^#(ok(X)) -> c_47(top^#(active(X)))}
{top^#(ok(X)) -> c_47(top^#(active(X)))}
==> {top^#(mark(X)) -> c_46(top^#(proper(X)))}
We consider the following path(s):
1) { top^#(mark(X)) -> c_46(top^#(proper(X)))
, top^#(ok(X)) -> c_47(top^#(active(X)))}
The usable rules for this path are the following:
{ active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(V)) -> mark(isQid(V))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(__(X1, X2)) -> __(active(X1), X2)
, active(__(X1, X2)) -> __(X1, active(X2))
, active(and(X1, X2)) -> and(active(X1), X2)
, proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(nil()) -> ok(nil())
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(tt()) -> ok(tt())
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(V)) -> mark(isQid(V))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(__(X1, X2)) -> __(active(X1), X2)
, active(__(X1, X2)) -> __(X1, active(X2))
, active(and(X1, X2)) -> and(active(X1), X2)
, proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(nil()) -> ok(nil())
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(tt()) -> ok(tt())
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))
, top^#(mark(X)) -> c_46(top^#(proper(X)))
, top^#(ok(X)) -> c_47(top^#(active(X)))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [1] x1 + [0]
c_46(x1) = [1] x1 + [0]
c_47(x1) = [1] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
and weakly orienting the rules
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [1] x1 + [0]
c_46(x1) = [1] x1 + [1]
c_47(x1) = [1] x1 + [1]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{top^#(ok(X)) -> c_47(top^#(active(X)))}
and weakly orienting the rules
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{top^#(ok(X)) -> c_47(top^#(active(X)))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [9]
ok(x1) = [1] x1 + [9]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [1] x1 + [0]
c_46(x1) = [1] x1 + [0]
c_47(x1) = [1] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(isQid(u())) -> mark(tt())}
and weakly orienting the rules
{ top^#(ok(X)) -> c_47(top^#(active(X)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(isQid(u())) -> mark(tt())}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [1]
proper(x1) = [1] x1 + [2]
ok(x1) = [1] x1 + [2]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [1] x1 + [0]
c_46(x1) = [1] x1 + [1]
c_47(x1) = [1] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ active(isNeList(V)) -> mark(isQid(V))
, active(isQid(a())) -> mark(tt())}
and weakly orienting the rules
{ active(isQid(u())) -> mark(tt())
, top^#(ok(X)) -> c_47(top^#(active(X)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ active(isNeList(V)) -> mark(isQid(V))
, active(isQid(a())) -> mark(tt())}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [2]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [4]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [3]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [1] x1 + [2]
c_46(x1) = [1] x1 + [0]
c_47(x1) = [1] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(e())) -> mark(tt())}
and weakly orienting the rules
{ active(isNeList(V)) -> mark(isQid(V))
, active(isQid(a())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, top^#(ok(X)) -> c_47(top^#(active(X)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(e())) -> mark(tt())}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [10]
a() = [13]
e() = [2]
i() = [0]
o() = [0]
u() = [2]
proper(x1) = [1] x1 + [3]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [1] x1 + [4]
c_46(x1) = [1] x1 + [0]
c_47(x1) = [1] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(isQid(o())) -> mark(tt())}
and weakly orienting the rules
{ active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(a())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, top^#(ok(X)) -> c_47(top^#(active(X)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(isQid(o())) -> mark(tt())}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [2]
a() = [0]
e() = [4]
i() = [0]
o() = [4]
u() = [0]
proper(x1) = [1] x1 + [12]
ok(x1) = [1] x1 + [2]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [1] x1 + [7]
c_46(x1) = [1] x1 + [0]
c_47(x1) = [1] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(isQid(i())) -> mark(tt())}
and weakly orienting the rules
{ active(isQid(o())) -> mark(tt())
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(a())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, top^#(ok(X)) -> c_47(top^#(active(X)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(isQid(i())) -> mark(tt())}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [1]
a() = [0]
e() = [0]
i() = [1]
o() = [2]
u() = [1]
proper(x1) = [1] x1 + [4]
ok(x1) = [1] x1 + [4]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [1] x1 + [0]
c_46(x1) = [1] x1 + [1]
c_47(x1) = [1] x1 + [1]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(isNePal(V)) -> mark(isQid(V))}
and weakly orienting the rules
{ active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(a())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, top^#(ok(X)) -> c_47(top^#(active(X)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(isNePal(V)) -> mark(isQid(V))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [4]
isPal(x1) = [1] x1 + [8]
a() = [8]
e() = [0]
i() = [1]
o() = [1]
u() = [8]
proper(x1) = [1] x1 + [8]
ok(x1) = [1] x1 + [8]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [1] x1 + [0]
c_46(x1) = [1] x1 + [9]
c_47(x1) = [1] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())}
and weakly orienting the rules
{ active(isNePal(V)) -> mark(isQid(V))
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(a())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, top^#(ok(X)) -> c_47(top^#(active(X)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [8]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [8]
a() = [0]
e() = [0]
i() = [2]
o() = [0]
u() = [6]
proper(x1) = [1] x1 + [4]
ok(x1) = [1] x1 + [4]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [1] x1 + [12]
c_46(x1) = [1] x1 + [1]
c_47(x1) = [1] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)}
and weakly orienting the rules
{ active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(a())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, top^#(ok(X)) -> c_47(top^#(active(X)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [1]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [14]
isNeList(x1) = [1] x1 + [14]
isQid(x1) = [1] x1 + [14]
isNePal(x1) = [1] x1 + [14]
isPal(x1) = [1] x1 + [14]
a() = [3]
e() = [1]
i() = [0]
o() = [3]
u() = [1]
proper(x1) = [1] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [1] x1 + [8]
c_46(x1) = [1] x1 + [3]
c_47(x1) = [1] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ active(and(tt(), X)) -> mark(X)
, active(isNePal(__(I, __(P, I)))) ->
mark(and(isQid(I), isPal(P)))}
and weakly orienting the rules
{ active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(a())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, top^#(ok(X)) -> c_47(top^#(active(X)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ active(and(tt(), X)) -> mark(X)
, active(isNePal(__(I, __(P, I)))) ->
mark(and(isQid(I), isPal(P)))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [7]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [4]
tt() = [5]
isList(x1) = [1] x1 + [8]
isNeList(x1) = [1] x1 + [2]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [8]
a() = [9]
e() = [5]
i() = [9]
o() = [8]
u() = [10]
proper(x1) = [1] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [1] x1 + [0]
c_46(x1) = [1] x1 + [0]
c_47(x1) = [1] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))}
and weakly orienting the rules
{ active(and(tt(), X)) -> mark(X)
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(a())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, top^#(ok(X)) -> c_47(top^#(active(X)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [2]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [1]
e() = [9]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [1] x1 + [0]
c_46(x1) = [1] x1 + [0]
c_47(x1) = [1] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))}
and weakly orienting the rules
{ active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(and(tt(), X)) -> mark(X)
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(a())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, top^#(ok(X)) -> c_47(top^#(active(X)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [2]
__(x1, x2) = [1] x1 + [1] x2 + [8]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [2]
tt() = [0]
isList(x1) = [1] x1 + [6]
isNeList(x1) = [1] x1 + [8]
isQid(x1) = [1] x1 + [2]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [8]
a() = [0]
e() = [12]
i() = [1]
o() = [3]
u() = [2]
proper(x1) = [1] x1 + [8]
ok(x1) = [1] x1 + [5]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [1] x1 + [3]
c_46(x1) = [1] x1 + [0]
c_47(x1) = [1] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ active(__(X1, X2)) -> __(active(X1), X2)
, active(__(X1, X2)) -> __(X1, active(X2))
, active(and(X1, X2)) -> and(active(X1), X2)
, proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))
, top^#(mark(X)) -> c_46(top^#(proper(X)))}
Weak Rules:
{ active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(and(tt(), X)) -> mark(X)
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(a())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, top^#(ok(X)) -> c_47(top^#(active(X)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ active(__(X1, X2)) -> __(active(X1), X2)
, active(__(X1, X2)) -> __(X1, active(X2))
, active(and(X1, X2)) -> and(active(X1), X2)
, proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))
, top^#(mark(X)) -> c_46(top^#(proper(X)))}
Weak Rules:
{ active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(and(tt(), X)) -> mark(X)
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(a())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, top^#(ok(X)) -> c_47(top^#(active(X)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
Details:
The problem is Match-bounded by 1.
The enriched problem is compatible with the following automaton:
{ active_0(2) -> 4
, active_1(2) -> 8
, active_1(9) -> 11
, mark_0(2) -> 2
, nil_0() -> 2
, nil_1() -> 9
, tt_0() -> 2
, tt_1() -> 9
, a_0() -> 2
, a_1() -> 9
, e_0() -> 2
, e_1() -> 9
, i_0() -> 2
, i_1() -> 9
, o_0() -> 2
, o_1() -> 9
, u_0() -> 2
, u_1() -> 9
, proper_1(2) -> 6
, ok_0(2) -> 2
, ok_1(9) -> 6
, top^#_0(2) -> 1
, top^#_0(4) -> 3
, top^#_1(6) -> 5
, top^#_1(8) -> 7
, top^#_1(11) -> 10
, c_46_1(5) -> 1
, c_47_0(3) -> 1
, c_47_1(7) -> 1
, c_47_1(10) -> 5}
2) {active^#(and(X1, X2)) -> c_21(and^#(active(X1), X2))}
The usable rules for this path are the following:
{ active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(V)) -> mark(isQid(V))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(__(X1, X2)) -> __(active(X1), X2)
, active(__(X1, X2)) -> __(X1, active(X2))
, active(and(X1, X2)) -> and(active(X1), X2)
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(V)) -> mark(isQid(V))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(__(X1, X2)) -> __(active(X1), X2)
, active(__(X1, X2)) -> __(X1, active(X2))
, active(and(X1, X2)) -> and(active(X1), X2)
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))
, active^#(and(X1, X2)) -> c_21(and^#(active(X1), X2))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [15]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [5]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [1] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(isNeList(V)) -> mark(isQid(V))}
and weakly orienting the rules
{ active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(isNeList(V)) -> mark(isQid(V))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [4]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [4]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [1] x1 + [7]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active^#(and(X1, X2)) -> c_21(and^#(active(X1), X2))}
and weakly orienting the rules
{ active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active^#(and(X1, X2)) -> c_21(and^#(active(X1), X2))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [5]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [1] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(isQid(o())) -> mark(tt())}
and weakly orienting the rules
{ active^#(and(X1, X2)) -> c_21(and^#(active(X1), X2))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(isQid(o())) -> mark(tt())}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [12]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [1] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(isQid(u())) -> mark(tt())}
and weakly orienting the rules
{ active(isQid(o())) -> mark(tt())
, active^#(and(X1, X2)) -> c_21(and^#(active(X1), X2))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(isQid(u())) -> mark(tt())}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [2]
u() = [4]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [1] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(isQid(i())) -> mark(tt())}
and weakly orienting the rules
{ active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(and(X1, X2)) -> c_21(and^#(active(X1), X2))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(isQid(i())) -> mark(tt())}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [12]
i() = [8]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [1] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(isQid(a())) -> mark(tt())}
and weakly orienting the rules
{ active(isQid(i())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(and(X1, X2)) -> c_21(and^#(active(X1), X2))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(isQid(a())) -> mark(tt())}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [8]
e() = [0]
i() = [0]
o() = [8]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [1] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) ->
mark(and(isQid(I), isPal(P)))}
and weakly orienting the rules
{ active(isQid(a())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(and(X1, X2)) -> c_21(and^#(active(X1), X2))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) ->
mark(and(isQid(I), isPal(P)))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [1]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [4]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [1] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(isList(nil())) -> mark(tt())}
and weakly orienting the rules
{ active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isQid(a())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(and(X1, X2)) -> c_21(and^#(active(X1), X2))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(isList(nil())) -> mark(tt())}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [4]
isNeList(x1) = [1] x1 + [4]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [10]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [1] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(isPal(nil())) -> mark(tt())}
and weakly orienting the rules
{ active(isList(nil())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isQid(a())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(and(X1, X2)) -> c_21(and^#(active(X1), X2))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(isPal(nil())) -> mark(tt())}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [8]
isPal(x1) = [1] x1 + [1]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [4]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [1] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(and(tt(), X)) -> mark(X)}
and weakly orienting the rules
{ active(isPal(nil())) -> mark(tt())
, active(isList(nil())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isQid(a())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(and(X1, X2)) -> c_21(and^#(active(X1), X2))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(and(tt(), X)) -> mark(X)}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [8]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [8]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [12]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [1] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(isList(V)) -> mark(isNeList(V))}
and weakly orienting the rules
{ active(and(tt(), X)) -> mark(X)
, active(isPal(nil())) -> mark(tt())
, active(isList(nil())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isQid(a())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(and(X1, X2)) -> c_21(and^#(active(X1), X2))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(isList(V)) -> mark(isNeList(V))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [8]
tt() = [0]
isList(x1) = [1] x1 + [8]
isNeList(x1) = [1] x1 + [1]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [8]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [15]
i() = [0]
o() = [8]
u() = [2]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [8]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [1] x1 + [1]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)}
and weakly orienting the rules
{ active(isList(V)) -> mark(isNeList(V))
, active(and(tt(), X)) -> mark(X)
, active(isPal(nil())) -> mark(tt())
, active(isList(nil())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isQid(a())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(and(X1, X2)) -> c_21(and^#(active(X1), X2))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [6]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [8]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [8]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [8]
i() = [2]
o() = [9]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [1] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isPal(V)) -> mark(isNePal(V))}
and weakly orienting the rules
{ active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(and(tt(), X)) -> mark(X)
, active(isPal(nil())) -> mark(tt())
, active(isList(nil())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isQid(a())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(and(X1, X2)) -> c_21(and^#(active(X1), X2))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isPal(V)) -> mark(isNePal(V))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [2]
mark(x1) = [1] x1 + [0]
nil() = [14]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [4]
isPal(x1) = [1] x1 + [8]
a() = [0]
e() = [1]
i() = [2]
o() = [0]
u() = [1]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [1] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))}
and weakly orienting the rules
{ active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isPal(V)) -> mark(isNePal(V))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(and(tt(), X)) -> mark(X)
, active(isPal(nil())) -> mark(tt())
, active(isList(nil())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isQid(a())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(and(X1, X2)) -> c_21(and^#(active(X1), X2))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [11]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [0]
nil() = [7]
and(x1, x2) = [1] x1 + [1] x2 + [4]
tt() = [0]
isList(x1) = [1] x1 + [5]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [1]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [1]
a() = [0]
e() = [3]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [1] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ active(__(X1, X2)) -> __(active(X1), X2)
, active(__(X1, X2)) -> __(X1, active(X2))
, active(and(X1, X2)) -> and(active(X1), X2)
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isPal(V)) -> mark(isNePal(V))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(and(tt(), X)) -> mark(X)
, active(isPal(nil())) -> mark(tt())
, active(isList(nil())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isQid(a())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(and(X1, X2)) -> c_21(and^#(active(X1), X2))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ active(__(X1, X2)) -> __(active(X1), X2)
, active(__(X1, X2)) -> __(X1, active(X2))
, active(and(X1, X2)) -> and(active(X1), X2)
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isPal(V)) -> mark(isNePal(V))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(and(tt(), X)) -> mark(X)
, active(isPal(nil())) -> mark(tt())
, active(isList(nil())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isQid(a())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(and(X1, X2)) -> c_21(and^#(active(X1), X2))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ mark_0(3) -> 3
, mark_0(4) -> 3
, mark_0(6) -> 3
, mark_0(12) -> 3
, mark_0(13) -> 3
, mark_0(14) -> 3
, mark_0(15) -> 3
, mark_0(16) -> 3
, mark_0(18) -> 3
, nil_0() -> 4
, tt_0() -> 6
, a_0() -> 12
, e_0() -> 13
, i_0() -> 14
, o_0() -> 15
, u_0() -> 16
, ok_0(3) -> 18
, ok_0(4) -> 18
, ok_0(6) -> 18
, ok_0(12) -> 18
, ok_0(13) -> 18
, ok_0(14) -> 18
, ok_0(15) -> 18
, ok_0(16) -> 18
, ok_0(18) -> 18
, active^#_0(3) -> 20
, active^#_0(4) -> 20
, active^#_0(6) -> 20
, active^#_0(12) -> 20
, active^#_0(13) -> 20
, active^#_0(14) -> 20
, active^#_0(15) -> 20
, active^#_0(16) -> 20
, active^#_0(18) -> 20
, and^#_0(3, 3) -> 30
, and^#_0(3, 4) -> 30
, and^#_0(3, 6) -> 30
, and^#_0(3, 12) -> 30
, and^#_0(3, 13) -> 30
, and^#_0(3, 14) -> 30
, and^#_0(3, 15) -> 30
, and^#_0(3, 16) -> 30
, and^#_0(3, 18) -> 30
, and^#_0(4, 3) -> 30
, and^#_0(4, 4) -> 30
, and^#_0(4, 6) -> 30
, and^#_0(4, 12) -> 30
, and^#_0(4, 13) -> 30
, and^#_0(4, 14) -> 30
, and^#_0(4, 15) -> 30
, and^#_0(4, 16) -> 30
, and^#_0(4, 18) -> 30
, and^#_0(6, 3) -> 30
, and^#_0(6, 4) -> 30
, and^#_0(6, 6) -> 30
, and^#_0(6, 12) -> 30
, and^#_0(6, 13) -> 30
, and^#_0(6, 14) -> 30
, and^#_0(6, 15) -> 30
, and^#_0(6, 16) -> 30
, and^#_0(6, 18) -> 30
, and^#_0(12, 3) -> 30
, and^#_0(12, 4) -> 30
, and^#_0(12, 6) -> 30
, and^#_0(12, 12) -> 30
, and^#_0(12, 13) -> 30
, and^#_0(12, 14) -> 30
, and^#_0(12, 15) -> 30
, and^#_0(12, 16) -> 30
, and^#_0(12, 18) -> 30
, and^#_0(13, 3) -> 30
, and^#_0(13, 4) -> 30
, and^#_0(13, 6) -> 30
, and^#_0(13, 12) -> 30
, and^#_0(13, 13) -> 30
, and^#_0(13, 14) -> 30
, and^#_0(13, 15) -> 30
, and^#_0(13, 16) -> 30
, and^#_0(13, 18) -> 30
, and^#_0(14, 3) -> 30
, and^#_0(14, 4) -> 30
, and^#_0(14, 6) -> 30
, and^#_0(14, 12) -> 30
, and^#_0(14, 13) -> 30
, and^#_0(14, 14) -> 30
, and^#_0(14, 15) -> 30
, and^#_0(14, 16) -> 30
, and^#_0(14, 18) -> 30
, and^#_0(15, 3) -> 30
, and^#_0(15, 4) -> 30
, and^#_0(15, 6) -> 30
, and^#_0(15, 12) -> 30
, and^#_0(15, 13) -> 30
, and^#_0(15, 14) -> 30
, and^#_0(15, 15) -> 30
, and^#_0(15, 16) -> 30
, and^#_0(15, 18) -> 30
, and^#_0(16, 3) -> 30
, and^#_0(16, 4) -> 30
, and^#_0(16, 6) -> 30
, and^#_0(16, 12) -> 30
, and^#_0(16, 13) -> 30
, and^#_0(16, 14) -> 30
, and^#_0(16, 15) -> 30
, and^#_0(16, 16) -> 30
, and^#_0(16, 18) -> 30
, and^#_0(18, 3) -> 30
, and^#_0(18, 4) -> 30
, and^#_0(18, 6) -> 30
, and^#_0(18, 12) -> 30
, and^#_0(18, 13) -> 30
, and^#_0(18, 14) -> 30
, and^#_0(18, 15) -> 30
, and^#_0(18, 16) -> 30
, and^#_0(18, 18) -> 30}
3) {active^#(__(X1, X2)) -> c_20(__^#(X1, active(X2)))}
The usable rules for this path are the following:
{ active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(V)) -> mark(isQid(V))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(__(X1, X2)) -> __(active(X1), X2)
, active(__(X1, X2)) -> __(X1, active(X2))
, active(and(X1, X2)) -> and(active(X1), X2)
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(V)) -> mark(isQid(V))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(__(X1, X2)) -> __(active(X1), X2)
, active(__(X1, X2)) -> __(X1, active(X2))
, active(and(X1, X2)) -> and(active(X1), X2)
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))
, active^#(__(X1, X2)) -> c_20(__^#(X1, active(X2)))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [15]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [1] x1 + [3]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(isNeList(V)) -> mark(isQid(V))}
and weakly orienting the rules
{ active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(isNeList(V)) -> mark(isQid(V))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [4]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [4]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [1] x1 + [7]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active^#(__(X1, X2)) -> c_20(__^#(X1, active(X2)))}
and weakly orienting the rules
{ active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active^#(__(X1, X2)) -> c_20(__^#(X1, active(X2)))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [5]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [1] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(isQid(o())) -> mark(tt())}
and weakly orienting the rules
{ active^#(__(X1, X2)) -> c_20(__^#(X1, active(X2)))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(isQid(o())) -> mark(tt())}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [12]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [1] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(isQid(u())) -> mark(tt())}
and weakly orienting the rules
{ active(isQid(o())) -> mark(tt())
, active^#(__(X1, X2)) -> c_20(__^#(X1, active(X2)))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(isQid(u())) -> mark(tt())}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [2]
u() = [4]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [1] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(isQid(i())) -> mark(tt())}
and weakly orienting the rules
{ active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(__(X1, X2)) -> c_20(__^#(X1, active(X2)))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(isQid(i())) -> mark(tt())}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [12]
i() = [8]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [1] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(isQid(a())) -> mark(tt())}
and weakly orienting the rules
{ active(isQid(i())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(__(X1, X2)) -> c_20(__^#(X1, active(X2)))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(isQid(a())) -> mark(tt())}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [8]
e() = [0]
i() = [0]
o() = [8]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [1] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) ->
mark(and(isQid(I), isPal(P)))}
and weakly orienting the rules
{ active(isQid(a())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(__(X1, X2)) -> c_20(__^#(X1, active(X2)))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) ->
mark(and(isQid(I), isPal(P)))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [1]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [4]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [1] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(isList(nil())) -> mark(tt())}
and weakly orienting the rules
{ active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isQid(a())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(__(X1, X2)) -> c_20(__^#(X1, active(X2)))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(isList(nil())) -> mark(tt())}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [4]
isNeList(x1) = [1] x1 + [4]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [10]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [1] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(isPal(nil())) -> mark(tt())}
and weakly orienting the rules
{ active(isList(nil())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isQid(a())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(__(X1, X2)) -> c_20(__^#(X1, active(X2)))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(isPal(nil())) -> mark(tt())}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [8]
isPal(x1) = [1] x1 + [1]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [4]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [1] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(and(tt(), X)) -> mark(X)}
and weakly orienting the rules
{ active(isPal(nil())) -> mark(tt())
, active(isList(nil())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isQid(a())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(__(X1, X2)) -> c_20(__^#(X1, active(X2)))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(and(tt(), X)) -> mark(X)}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [8]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [8]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [12]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [1] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(isList(V)) -> mark(isNeList(V))}
and weakly orienting the rules
{ active(and(tt(), X)) -> mark(X)
, active(isPal(nil())) -> mark(tt())
, active(isList(nil())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isQid(a())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(__(X1, X2)) -> c_20(__^#(X1, active(X2)))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(isList(V)) -> mark(isNeList(V))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [8]
tt() = [0]
isList(x1) = [1] x1 + [8]
isNeList(x1) = [1] x1 + [1]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [8]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [15]
i() = [0]
o() = [8]
u() = [2]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [8]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [1] x1 + [1]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)}
and weakly orienting the rules
{ active(isList(V)) -> mark(isNeList(V))
, active(and(tt(), X)) -> mark(X)
, active(isPal(nil())) -> mark(tt())
, active(isList(nil())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isQid(a())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(__(X1, X2)) -> c_20(__^#(X1, active(X2)))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [6]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [8]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [8]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [8]
i() = [2]
o() = [9]
u() = [8]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [1] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isPal(V)) -> mark(isNePal(V))}
and weakly orienting the rules
{ active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(and(tt(), X)) -> mark(X)
, active(isPal(nil())) -> mark(tt())
, active(isList(nil())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isQid(a())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(__(X1, X2)) -> c_20(__^#(X1, active(X2)))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isPal(V)) -> mark(isNePal(V))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [2]
mark(x1) = [1] x1 + [0]
nil() = [14]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [4]
isPal(x1) = [1] x1 + [8]
a() = [0]
e() = [1]
i() = [2]
o() = [0]
u() = [1]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [1] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))}
and weakly orienting the rules
{ active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isPal(V)) -> mark(isNePal(V))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(and(tt(), X)) -> mark(X)
, active(isPal(nil())) -> mark(tt())
, active(isList(nil())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isQid(a())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(__(X1, X2)) -> c_20(__^#(X1, active(X2)))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [11]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [0]
nil() = [15]
and(x1, x2) = [1] x1 + [1] x2 + [4]
tt() = [2]
isList(x1) = [1] x1 + [5]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [1]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [13]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [1] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ active(__(X1, X2)) -> __(active(X1), X2)
, active(__(X1, X2)) -> __(X1, active(X2))
, active(and(X1, X2)) -> and(active(X1), X2)
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isPal(V)) -> mark(isNePal(V))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(and(tt(), X)) -> mark(X)
, active(isPal(nil())) -> mark(tt())
, active(isList(nil())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isQid(a())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(__(X1, X2)) -> c_20(__^#(X1, active(X2)))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ active(__(X1, X2)) -> __(active(X1), X2)
, active(__(X1, X2)) -> __(X1, active(X2))
, active(and(X1, X2)) -> and(active(X1), X2)
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isPal(V)) -> mark(isNePal(V))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(and(tt(), X)) -> mark(X)
, active(isPal(nil())) -> mark(tt())
, active(isList(nil())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isQid(a())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(__(X1, X2)) -> c_20(__^#(X1, active(X2)))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ mark_0(3) -> 3
, mark_0(4) -> 3
, mark_0(6) -> 3
, mark_0(12) -> 3
, mark_0(13) -> 3
, mark_0(14) -> 3
, mark_0(15) -> 3
, mark_0(16) -> 3
, mark_0(18) -> 3
, nil_0() -> 4
, tt_0() -> 6
, a_0() -> 12
, e_0() -> 13
, i_0() -> 14
, o_0() -> 15
, u_0() -> 16
, ok_0(3) -> 18
, ok_0(4) -> 18
, ok_0(6) -> 18
, ok_0(12) -> 18
, ok_0(13) -> 18
, ok_0(14) -> 18
, ok_0(15) -> 18
, ok_0(16) -> 18
, ok_0(18) -> 18
, active^#_0(3) -> 20
, active^#_0(4) -> 20
, active^#_0(6) -> 20
, active^#_0(12) -> 20
, active^#_0(13) -> 20
, active^#_0(14) -> 20
, active^#_0(15) -> 20
, active^#_0(16) -> 20
, active^#_0(18) -> 20
, __^#_0(3, 3) -> 22
, __^#_0(3, 4) -> 22
, __^#_0(3, 6) -> 22
, __^#_0(3, 12) -> 22
, __^#_0(3, 13) -> 22
, __^#_0(3, 14) -> 22
, __^#_0(3, 15) -> 22
, __^#_0(3, 16) -> 22
, __^#_0(3, 18) -> 22
, __^#_0(4, 3) -> 22
, __^#_0(4, 4) -> 22
, __^#_0(4, 6) -> 22
, __^#_0(4, 12) -> 22
, __^#_0(4, 13) -> 22
, __^#_0(4, 14) -> 22
, __^#_0(4, 15) -> 22
, __^#_0(4, 16) -> 22
, __^#_0(4, 18) -> 22
, __^#_0(6, 3) -> 22
, __^#_0(6, 4) -> 22
, __^#_0(6, 6) -> 22
, __^#_0(6, 12) -> 22
, __^#_0(6, 13) -> 22
, __^#_0(6, 14) -> 22
, __^#_0(6, 15) -> 22
, __^#_0(6, 16) -> 22
, __^#_0(6, 18) -> 22
, __^#_0(12, 3) -> 22
, __^#_0(12, 4) -> 22
, __^#_0(12, 6) -> 22
, __^#_0(12, 12) -> 22
, __^#_0(12, 13) -> 22
, __^#_0(12, 14) -> 22
, __^#_0(12, 15) -> 22
, __^#_0(12, 16) -> 22
, __^#_0(12, 18) -> 22
, __^#_0(13, 3) -> 22
, __^#_0(13, 4) -> 22
, __^#_0(13, 6) -> 22
, __^#_0(13, 12) -> 22
, __^#_0(13, 13) -> 22
, __^#_0(13, 14) -> 22
, __^#_0(13, 15) -> 22
, __^#_0(13, 16) -> 22
, __^#_0(13, 18) -> 22
, __^#_0(14, 3) -> 22
, __^#_0(14, 4) -> 22
, __^#_0(14, 6) -> 22
, __^#_0(14, 12) -> 22
, __^#_0(14, 13) -> 22
, __^#_0(14, 14) -> 22
, __^#_0(14, 15) -> 22
, __^#_0(14, 16) -> 22
, __^#_0(14, 18) -> 22
, __^#_0(15, 3) -> 22
, __^#_0(15, 4) -> 22
, __^#_0(15, 6) -> 22
, __^#_0(15, 12) -> 22
, __^#_0(15, 13) -> 22
, __^#_0(15, 14) -> 22
, __^#_0(15, 15) -> 22
, __^#_0(15, 16) -> 22
, __^#_0(15, 18) -> 22
, __^#_0(16, 3) -> 22
, __^#_0(16, 4) -> 22
, __^#_0(16, 6) -> 22
, __^#_0(16, 12) -> 22
, __^#_0(16, 13) -> 22
, __^#_0(16, 14) -> 22
, __^#_0(16, 15) -> 22
, __^#_0(16, 16) -> 22
, __^#_0(16, 18) -> 22
, __^#_0(18, 3) -> 22
, __^#_0(18, 4) -> 22
, __^#_0(18, 6) -> 22
, __^#_0(18, 12) -> 22
, __^#_0(18, 13) -> 22
, __^#_0(18, 14) -> 22
, __^#_0(18, 15) -> 22
, __^#_0(18, 16) -> 22
, __^#_0(18, 18) -> 22}
4) {active^#(__(X1, X2)) -> c_19(__^#(active(X1), X2))}
The usable rules for this path are the following:
{ active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(V)) -> mark(isQid(V))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(__(X1, X2)) -> __(active(X1), X2)
, active(__(X1, X2)) -> __(X1, active(X2))
, active(and(X1, X2)) -> and(active(X1), X2)
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(V)) -> mark(isQid(V))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(__(X1, X2)) -> __(active(X1), X2)
, active(__(X1, X2)) -> __(X1, active(X2))
, active(and(X1, X2)) -> and(active(X1), X2)
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))
, active^#(__(X1, X2)) -> c_19(__^#(active(X1), X2))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [15]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [1] x1 + [3]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(isNeList(V)) -> mark(isQid(V))}
and weakly orienting the rules
{ active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(isNeList(V)) -> mark(isQid(V))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [4]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [4]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [1] x1 + [7]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active^#(__(X1, X2)) -> c_19(__^#(active(X1), X2))}
and weakly orienting the rules
{ active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active^#(__(X1, X2)) -> c_19(__^#(active(X1), X2))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [5]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [1] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(isQid(o())) -> mark(tt())}
and weakly orienting the rules
{ active^#(__(X1, X2)) -> c_19(__^#(active(X1), X2))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(isQid(o())) -> mark(tt())}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [12]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [1] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(isQid(u())) -> mark(tt())}
and weakly orienting the rules
{ active(isQid(o())) -> mark(tt())
, active^#(__(X1, X2)) -> c_19(__^#(active(X1), X2))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(isQid(u())) -> mark(tt())}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [2]
u() = [4]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [1] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(isQid(i())) -> mark(tt())}
and weakly orienting the rules
{ active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(__(X1, X2)) -> c_19(__^#(active(X1), X2))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(isQid(i())) -> mark(tt())}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [12]
i() = [8]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [1] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(isQid(a())) -> mark(tt())}
and weakly orienting the rules
{ active(isQid(i())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(__(X1, X2)) -> c_19(__^#(active(X1), X2))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(isQid(a())) -> mark(tt())}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [8]
e() = [0]
i() = [0]
o() = [8]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [1] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) ->
mark(and(isQid(I), isPal(P)))}
and weakly orienting the rules
{ active(isQid(a())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(__(X1, X2)) -> c_19(__^#(active(X1), X2))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) ->
mark(and(isQid(I), isPal(P)))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [1]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [4]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [1] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(isList(nil())) -> mark(tt())}
and weakly orienting the rules
{ active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isQid(a())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(__(X1, X2)) -> c_19(__^#(active(X1), X2))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(isList(nil())) -> mark(tt())}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [4]
isNeList(x1) = [1] x1 + [4]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [10]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [1] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(isPal(nil())) -> mark(tt())}
and weakly orienting the rules
{ active(isList(nil())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isQid(a())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(__(X1, X2)) -> c_19(__^#(active(X1), X2))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(isPal(nil())) -> mark(tt())}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [8]
isPal(x1) = [1] x1 + [1]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [4]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [1] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(and(tt(), X)) -> mark(X)}
and weakly orienting the rules
{ active(isPal(nil())) -> mark(tt())
, active(isList(nil())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isQid(a())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(__(X1, X2)) -> c_19(__^#(active(X1), X2))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(and(tt(), X)) -> mark(X)}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [8]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [8]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [12]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [1] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(isList(V)) -> mark(isNeList(V))}
and weakly orienting the rules
{ active(and(tt(), X)) -> mark(X)
, active(isPal(nil())) -> mark(tt())
, active(isList(nil())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isQid(a())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(__(X1, X2)) -> c_19(__^#(active(X1), X2))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(isList(V)) -> mark(isNeList(V))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [8]
tt() = [0]
isList(x1) = [1] x1 + [8]
isNeList(x1) = [1] x1 + [1]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [8]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [15]
i() = [0]
o() = [8]
u() = [2]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [8]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [1] x1 + [1]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)}
and weakly orienting the rules
{ active(isList(V)) -> mark(isNeList(V))
, active(and(tt(), X)) -> mark(X)
, active(isPal(nil())) -> mark(tt())
, active(isList(nil())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isQid(a())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(__(X1, X2)) -> c_19(__^#(active(X1), X2))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [6]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [8]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [8]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [8]
i() = [2]
o() = [9]
u() = [8]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [1] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isPal(V)) -> mark(isNePal(V))}
and weakly orienting the rules
{ active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(and(tt(), X)) -> mark(X)
, active(isPal(nil())) -> mark(tt())
, active(isList(nil())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isQid(a())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(__(X1, X2)) -> c_19(__^#(active(X1), X2))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isPal(V)) -> mark(isNePal(V))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [2]
mark(x1) = [1] x1 + [0]
nil() = [14]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [4]
isPal(x1) = [1] x1 + [8]
a() = [0]
e() = [1]
i() = [2]
o() = [0]
u() = [1]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [1] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))}
and weakly orienting the rules
{ active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isPal(V)) -> mark(isNePal(V))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(and(tt(), X)) -> mark(X)
, active(isPal(nil())) -> mark(tt())
, active(isList(nil())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isQid(a())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(__(X1, X2)) -> c_19(__^#(active(X1), X2))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [11]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [0]
nil() = [15]
and(x1, x2) = [1] x1 + [1] x2 + [4]
tt() = [2]
isList(x1) = [1] x1 + [5]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [1]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [13]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [1] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ active(__(X1, X2)) -> __(active(X1), X2)
, active(__(X1, X2)) -> __(X1, active(X2))
, active(and(X1, X2)) -> and(active(X1), X2)
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isPal(V)) -> mark(isNePal(V))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(and(tt(), X)) -> mark(X)
, active(isPal(nil())) -> mark(tt())
, active(isList(nil())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isQid(a())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(__(X1, X2)) -> c_19(__^#(active(X1), X2))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ active(__(X1, X2)) -> __(active(X1), X2)
, active(__(X1, X2)) -> __(X1, active(X2))
, active(and(X1, X2)) -> and(active(X1), X2)
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isPal(V)) -> mark(isNePal(V))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(and(tt(), X)) -> mark(X)
, active(isPal(nil())) -> mark(tt())
, active(isList(nil())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isQid(a())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active^#(__(X1, X2)) -> c_19(__^#(active(X1), X2))
, active(isNeList(V)) -> mark(isQid(V))
, active(isQid(e())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ mark_0(3) -> 3
, mark_0(4) -> 3
, mark_0(6) -> 3
, mark_0(12) -> 3
, mark_0(13) -> 3
, mark_0(14) -> 3
, mark_0(15) -> 3
, mark_0(16) -> 3
, mark_0(18) -> 3
, nil_0() -> 4
, tt_0() -> 6
, a_0() -> 12
, e_0() -> 13
, i_0() -> 14
, o_0() -> 15
, u_0() -> 16
, ok_0(3) -> 18
, ok_0(4) -> 18
, ok_0(6) -> 18
, ok_0(12) -> 18
, ok_0(13) -> 18
, ok_0(14) -> 18
, ok_0(15) -> 18
, ok_0(16) -> 18
, ok_0(18) -> 18
, active^#_0(3) -> 20
, active^#_0(4) -> 20
, active^#_0(6) -> 20
, active^#_0(12) -> 20
, active^#_0(13) -> 20
, active^#_0(14) -> 20
, active^#_0(15) -> 20
, active^#_0(16) -> 20
, active^#_0(18) -> 20
, __^#_0(3, 3) -> 22
, __^#_0(3, 4) -> 22
, __^#_0(3, 6) -> 22
, __^#_0(3, 12) -> 22
, __^#_0(3, 13) -> 22
, __^#_0(3, 14) -> 22
, __^#_0(3, 15) -> 22
, __^#_0(3, 16) -> 22
, __^#_0(3, 18) -> 22
, __^#_0(4, 3) -> 22
, __^#_0(4, 4) -> 22
, __^#_0(4, 6) -> 22
, __^#_0(4, 12) -> 22
, __^#_0(4, 13) -> 22
, __^#_0(4, 14) -> 22
, __^#_0(4, 15) -> 22
, __^#_0(4, 16) -> 22
, __^#_0(4, 18) -> 22
, __^#_0(6, 3) -> 22
, __^#_0(6, 4) -> 22
, __^#_0(6, 6) -> 22
, __^#_0(6, 12) -> 22
, __^#_0(6, 13) -> 22
, __^#_0(6, 14) -> 22
, __^#_0(6, 15) -> 22
, __^#_0(6, 16) -> 22
, __^#_0(6, 18) -> 22
, __^#_0(12, 3) -> 22
, __^#_0(12, 4) -> 22
, __^#_0(12, 6) -> 22
, __^#_0(12, 12) -> 22
, __^#_0(12, 13) -> 22
, __^#_0(12, 14) -> 22
, __^#_0(12, 15) -> 22
, __^#_0(12, 16) -> 22
, __^#_0(12, 18) -> 22
, __^#_0(13, 3) -> 22
, __^#_0(13, 4) -> 22
, __^#_0(13, 6) -> 22
, __^#_0(13, 12) -> 22
, __^#_0(13, 13) -> 22
, __^#_0(13, 14) -> 22
, __^#_0(13, 15) -> 22
, __^#_0(13, 16) -> 22
, __^#_0(13, 18) -> 22
, __^#_0(14, 3) -> 22
, __^#_0(14, 4) -> 22
, __^#_0(14, 6) -> 22
, __^#_0(14, 12) -> 22
, __^#_0(14, 13) -> 22
, __^#_0(14, 14) -> 22
, __^#_0(14, 15) -> 22
, __^#_0(14, 16) -> 22
, __^#_0(14, 18) -> 22
, __^#_0(15, 3) -> 22
, __^#_0(15, 4) -> 22
, __^#_0(15, 6) -> 22
, __^#_0(15, 12) -> 22
, __^#_0(15, 13) -> 22
, __^#_0(15, 14) -> 22
, __^#_0(15, 15) -> 22
, __^#_0(15, 16) -> 22
, __^#_0(15, 18) -> 22
, __^#_0(16, 3) -> 22
, __^#_0(16, 4) -> 22
, __^#_0(16, 6) -> 22
, __^#_0(16, 12) -> 22
, __^#_0(16, 13) -> 22
, __^#_0(16, 14) -> 22
, __^#_0(16, 15) -> 22
, __^#_0(16, 16) -> 22
, __^#_0(16, 18) -> 22
, __^#_0(18, 3) -> 22
, __^#_0(18, 4) -> 22
, __^#_0(18, 6) -> 22
, __^#_0(18, 12) -> 22
, __^#_0(18, 13) -> 22
, __^#_0(18, 14) -> 22
, __^#_0(18, 15) -> 22
, __^#_0(18, 16) -> 22
, __^#_0(18, 18) -> 22}
5) { active^#(and(X1, X2)) -> c_21(and^#(active(X1), X2))
, and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
The usable rules for this path are the following:
{ active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(V)) -> mark(isQid(V))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(__(X1, X2)) -> __(active(X1), X2)
, active(__(X1, X2)) -> __(X1, active(X2))
, active(and(X1, X2)) -> and(active(X1), X2)
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(V)) -> mark(isQid(V))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(__(X1, X2)) -> __(active(X1), X2)
, active(__(X1, X2)) -> __(X1, active(X2))
, active(and(X1, X2)) -> and(active(X1), X2)
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))
, active^#(and(X1, X2)) -> c_21(and^#(active(X1), X2))
, and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [2]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [1] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [1] x1 + [1]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [1] x1 + [1]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))}
and weakly orienting the rules
{ active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [5]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [1] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [1] x1 + [1]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [1] x1 + [1]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ active(isNePal(V)) -> mark(isQid(V))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
and weakly orienting the rules
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ active(isNePal(V)) -> mark(isQid(V))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [2]
isPal(x1) = [1] x1 + [8]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [1] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [1] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [1] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())}
and weakly orienting the rules
{ active(isNePal(V)) -> mark(isQid(V))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [2]
isNePal(x1) = [1] x1 + [8]
isPal(x1) = [1] x1 + [15]
a() = [0]
e() = [0]
i() = [8]
o() = [2]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [8]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [1]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [1] x1 + [1]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [1] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [1] x1 + [5]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active^#(and(X1, X2)) -> c_21(and^#(active(X1), X2))}
and weakly orienting the rules
{ active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active^#(and(X1, X2)) -> c_21(and^#(active(X1), X2))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [4]
isPal(x1) = [1] x1 + [8]
a() = [0]
e() = [0]
i() = [8]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [1]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [1] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [1] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [1] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())}
and weakly orienting the rules
{ active^#(and(X1, X2)) -> c_21(and^#(active(X1), X2))
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [4]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [8]
e() = [12]
i() = [0]
o() = [0]
u() = [10]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [1] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [1] x1 + [1]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [1] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(isNeList(V)) -> mark(isQid(V))}
and weakly orienting the rules
{ active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active^#(and(X1, X2)) -> c_21(and^#(active(X1), X2))
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(isNeList(V)) -> mark(isQid(V))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [4]
isNeList(x1) = [1] x1 + [1]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [2]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [1] x1 + [3]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [1] x1 + [1]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [1] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(and(tt(), X)) -> mark(X)}
and weakly orienting the rules
{ active(isNeList(V)) -> mark(isQid(V))
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active^#(and(X1, X2)) -> c_21(and^#(active(X1), X2))
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(and(tt(), X)) -> mark(X)}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [4]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [1]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [1] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [1] x1 + [1]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [1] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isNePal(__(I, __(P, I)))) ->
mark(and(isQid(I), isPal(P)))}
and weakly orienting the rules
{ active(and(tt(), X)) -> mark(X)
, active(isNeList(V)) -> mark(isQid(V))
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active^#(and(X1, X2)) -> c_21(and^#(active(X1), X2))
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isNePal(__(I, __(P, I)))) ->
mark(and(isQid(I), isPal(P)))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [14]
mark(x1) = [1] x1 + [0]
nil() = [2]
and(x1, x2) = [1] x1 + [1] x2 + [4]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [1]
i() = [0]
o() = [0]
u() = [8]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [13]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [1]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [1] x1 + [1]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [1] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [1] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))}
and weakly orienting the rules
{ active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(and(tt(), X)) -> mark(X)
, active(isNeList(V)) -> mark(isQid(V))
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active^#(and(X1, X2)) -> c_21(and^#(active(X1), X2))
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [6]
__(x1, x2) = [1] x1 + [1] x2 + [4]
mark(x1) = [1] x1 + [2]
nil() = [2]
and(x1, x2) = [1] x1 + [1] x2 + [6]
tt() = [2]
isList(x1) = [1] x1 + [1]
isNeList(x1) = [1] x1 + [5]
isQid(x1) = [1] x1 + [5]
isNePal(x1) = [1] x1 + [1]
isPal(x1) = [1] x1 + [0]
a() = [6]
e() = [4]
i() = [8]
o() = [1]
u() = [12]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [1]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [1] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [1] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [1] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ active(__(X1, X2)) -> __(active(X1), X2)
, active(__(X1, X2)) -> __(X1, active(X2))
, active(and(X1, X2)) -> and(active(X1), X2)
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(and(tt(), X)) -> mark(X)
, active(isNeList(V)) -> mark(isQid(V))
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active^#(and(X1, X2)) -> c_21(and^#(active(X1), X2))
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ active(__(X1, X2)) -> __(active(X1), X2)
, active(__(X1, X2)) -> __(X1, active(X2))
, active(and(X1, X2)) -> and(active(X1), X2)
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(and(tt(), X)) -> mark(X)
, active(isNeList(V)) -> mark(isQid(V))
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active^#(and(X1, X2)) -> c_21(and^#(active(X1), X2))
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(isNePal(V)) -> mark(isQid(V))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ mark_0(2) -> 2
, nil_0() -> 2
, tt_0() -> 2
, a_0() -> 2
, e_0() -> 2
, i_0() -> 2
, o_0() -> 2
, u_0() -> 2
, ok_0(2) -> 2
, active^#_0(2) -> 1
, and^#_0(2, 2) -> 1
, c_24_0(1) -> 1
, c_40_0(1) -> 1}
6) { active^#(__(X1, X2)) -> c_19(__^#(active(X1), X2))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))
, __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))}
The usable rules for this path are the following:
{ active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(V)) -> mark(isQid(V))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(__(X1, X2)) -> __(active(X1), X2)
, active(__(X1, X2)) -> __(X1, active(X2))
, active(and(X1, X2)) -> and(active(X1), X2)
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(V)) -> mark(isQid(V))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(__(X1, X2)) -> __(active(X1), X2)
, active(__(X1, X2)) -> __(X1, active(X2))
, active(and(X1, X2)) -> and(active(X1), X2)
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))
, active^#(__(X1, X2)) -> c_19(__^#(active(X1), X2))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))
, __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isNeList(V)) -> mark(isQid(V))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isNeList(V)) -> mark(isQid(V))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [4]
tt() = [0]
isList(x1) = [1] x1 + [15]
isNeList(x1) = [1] x1 + [4]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [1] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [1] x1 + [1]
c_23(x1) = [1] x1 + [5]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [1] x1 + [1]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))}
and weakly orienting the rules
{ active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isNeList(V)) -> mark(isQid(V))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [7]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [1] x1 + [1]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [1] x1 + [0]
c_23(x1) = [1] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [1] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))}
and weakly orienting the rules
{ __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))
, active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isNeList(V)) -> mark(isQid(V))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [8]
isNeList(x1) = [1] x1 + [2]
isQid(x1) = [1] x1 + [2]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [4]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [6]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [1] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [1] x1 + [1]
c_23(x1) = [1] x1 + [1]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [1] x1 + [1]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(isNePal(V)) -> mark(isQid(V))}
and weakly orienting the rules
{ active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))
, __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))
, active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isNeList(V)) -> mark(isQid(V))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(isNePal(V)) -> mark(isQid(V))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [2]
isPal(x1) = [1] x1 + [2]
a() = [0]
e() = [2]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [2]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [1] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [1] x1 + [1]
c_23(x1) = [1] x1 + [1]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [1] x1 + [1]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active^#(__(X1, X2)) -> c_19(__^#(active(X1), X2))}
and weakly orienting the rules
{ active(isNePal(V)) -> mark(isQid(V))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))
, __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))
, active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isNeList(V)) -> mark(isQid(V))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active^#(__(X1, X2)) -> c_19(__^#(active(X1), X2))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [2]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [1] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [1] x1 + [1]
c_23(x1) = [1] x1 + [1]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [1] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)}
and weakly orienting the rules
{ active^#(__(X1, X2)) -> c_19(__^#(active(X1), X2))
, active(isNePal(V)) -> mark(isQid(V))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))
, __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))
, active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isNeList(V)) -> mark(isQid(V))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [2]
__(x1, x2) = [1] x1 + [1] x2 + [1]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [6]
isList(x1) = [1] x1 + [8]
isNeList(x1) = [1] x1 + [3]
isQid(x1) = [1] x1 + [4]
isNePal(x1) = [1] x1 + [2]
isPal(x1) = [1] x1 + [12]
a() = [13]
e() = [10]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [8]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [1] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [1] x1 + [0]
c_23(x1) = [1] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [1] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isNePal(__(I, __(P, I)))) ->
mark(and(isQid(I), isPal(P)))}
and weakly orienting the rules
{ active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active^#(__(X1, X2)) -> c_19(__^#(active(X1), X2))
, active(isNePal(V)) -> mark(isQid(V))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))
, __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))
, active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isNeList(V)) -> mark(isQid(V))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isNePal(__(I, __(P, I)))) ->
mark(and(isQid(I), isPal(P)))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [0]
nil() = [8]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [5]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [3]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [1] x1 + [1]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [1] x1 + [0]
c_23(x1) = [1] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [1] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ active(__(X1, X2)) -> __(active(X1), X2)
, active(__(X1, X2)) -> __(X1, active(X2))
, active(and(X1, X2)) -> and(active(X1), X2)
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active^#(__(X1, X2)) -> c_19(__^#(active(X1), X2))
, active(isNePal(V)) -> mark(isQid(V))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))
, __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))
, active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isNeList(V)) -> mark(isQid(V))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ active(__(X1, X2)) -> __(active(X1), X2)
, active(__(X1, X2)) -> __(X1, active(X2))
, active(and(X1, X2)) -> and(active(X1), X2)
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active^#(__(X1, X2)) -> c_19(__^#(active(X1), X2))
, active(isNePal(V)) -> mark(isQid(V))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))
, __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))
, active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isNeList(V)) -> mark(isQid(V))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ mark_0(2) -> 2
, nil_0() -> 2
, tt_0() -> 2
, a_0() -> 2
, e_0() -> 2
, i_0() -> 2
, o_0() -> 2
, u_0() -> 2
, ok_0(2) -> 2
, active^#_0(2) -> 1
, __^#_0(2, 2) -> 1
, c_22_0(1) -> 1
, c_23_0(1) -> 1
, c_39_0(1) -> 1}
7) { active^#(__(X1, X2)) -> c_20(__^#(X1, active(X2)))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))
, __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))}
The usable rules for this path are the following:
{ active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(V)) -> mark(isQid(V))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(__(X1, X2)) -> __(active(X1), X2)
, active(__(X1, X2)) -> __(X1, active(X2))
, active(and(X1, X2)) -> and(active(X1), X2)
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(V)) -> mark(isQid(V))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isNePal(V)) -> mark(isQid(V))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, active(__(X1, X2)) -> __(active(X1), X2)
, active(__(X1, X2)) -> __(X1, active(X2))
, active(and(X1, X2)) -> and(active(X1), X2)
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))
, active^#(__(X1, X2)) -> c_20(__^#(X1, active(X2)))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))
, __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isNeList(V)) -> mark(isQid(V))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isNeList(V)) -> mark(isQid(V))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [4]
tt() = [0]
isList(x1) = [1] x1 + [15]
isNeList(x1) = [1] x1 + [4]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [1] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [1] x1 + [1]
c_23(x1) = [1] x1 + [5]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [1] x1 + [1]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))}
and weakly orienting the rules
{ active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isNeList(V)) -> mark(isQid(V))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [7]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [1] x1 + [1]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [1] x1 + [0]
c_23(x1) = [1] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [1] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))}
and weakly orienting the rules
{ __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))
, active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isNeList(V)) -> mark(isQid(V))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [8]
isNeList(x1) = [1] x1 + [2]
isQid(x1) = [1] x1 + [2]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [4]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [6]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [1] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [1] x1 + [1]
c_23(x1) = [1] x1 + [1]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [1] x1 + [1]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active(isNePal(V)) -> mark(isQid(V))}
and weakly orienting the rules
{ active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))
, __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))
, active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isNeList(V)) -> mark(isQid(V))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active(isNePal(V)) -> mark(isQid(V))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [2]
isPal(x1) = [1] x1 + [2]
a() = [0]
e() = [2]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [2]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [1] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [1] x1 + [1]
c_23(x1) = [1] x1 + [1]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [1] x1 + [1]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active^#(__(X1, X2)) -> c_20(__^#(X1, active(X2)))}
and weakly orienting the rules
{ active(isNePal(V)) -> mark(isQid(V))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))
, __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))
, active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isNeList(V)) -> mark(isQid(V))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active^#(__(X1, X2)) -> c_20(__^#(X1, active(X2)))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [2]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [1] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [1] x1 + [1]
c_23(x1) = [1] x1 + [1]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [1] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)}
and weakly orienting the rules
{ active^#(__(X1, X2)) -> c_20(__^#(X1, active(X2)))
, active(isNePal(V)) -> mark(isQid(V))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))
, __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))
, active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isNeList(V)) -> mark(isQid(V))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [2]
__(x1, x2) = [1] x1 + [1] x2 + [1]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [6]
isList(x1) = [1] x1 + [8]
isNeList(x1) = [1] x1 + [3]
isQid(x1) = [1] x1 + [4]
isNePal(x1) = [1] x1 + [2]
isPal(x1) = [1] x1 + [12]
a() = [13]
e() = [10]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [8]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [1] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [1] x1 + [0]
c_23(x1) = [1] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [1] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isNePal(__(I, __(P, I)))) ->
mark(and(isQid(I), isPal(P)))}
and weakly orienting the rules
{ active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active^#(__(X1, X2)) -> c_20(__^#(X1, active(X2)))
, active(isNePal(V)) -> mark(isQid(V))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))
, __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))
, active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isNeList(V)) -> mark(isQid(V))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isNePal(__(I, __(P, I)))) ->
mark(and(isQid(I), isPal(P)))}
Details:
Interpretation Functions:
active(x1) = [1] x1 + [1]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [0]
nil() = [8]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [5]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [3]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [1] x1 + [1]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [1] x1 + [0]
c_23(x1) = [1] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [1] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ active(__(X1, X2)) -> __(active(X1), X2)
, active(__(X1, X2)) -> __(X1, active(X2))
, active(and(X1, X2)) -> and(active(X1), X2)
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active^#(__(X1, X2)) -> c_20(__^#(X1, active(X2)))
, active(isNePal(V)) -> mark(isQid(V))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))
, __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))
, active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isNeList(V)) -> mark(isQid(V))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ active(__(X1, X2)) -> __(active(X1), X2)
, active(__(X1, X2)) -> __(X1, active(X2))
, active(and(X1, X2)) -> and(active(X1), X2)
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ active(isList(__(V1, V2))) -> mark(and(isList(V1), isList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isList(V1), isNeList(V2)))
, active(isNeList(__(V1, V2))) ->
mark(and(isNeList(V1), isList(V2)))
, active(isNePal(__(I, __(P, I)))) -> mark(and(isQid(I), isPal(P)))
, active(__(__(X, Y), Z)) -> mark(__(X, __(Y, Z)))
, active(__(X, nil())) -> mark(X)
, active(__(nil(), X)) -> mark(X)
, active^#(__(X1, X2)) -> c_20(__^#(X1, active(X2)))
, active(isNePal(V)) -> mark(isQid(V))
, active(isPal(V)) -> mark(isNePal(V))
, active(isPal(nil())) -> mark(tt())
, active(isQid(a())) -> mark(tt())
, active(isQid(e())) -> mark(tt())
, active(isQid(i())) -> mark(tt())
, active(isQid(o())) -> mark(tt())
, active(isQid(u())) -> mark(tt())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))
, __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))
, active(and(tt(), X)) -> mark(X)
, active(isList(V)) -> mark(isNeList(V))
, active(isList(nil())) -> mark(tt())
, active(isNeList(V)) -> mark(isQid(V))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ mark_0(2) -> 2
, nil_0() -> 2
, tt_0() -> 2
, a_0() -> 2
, e_0() -> 2
, i_0() -> 2
, o_0() -> 2
, u_0() -> 2
, ok_0(2) -> 2
, active^#_0(2) -> 1
, __^#_0(2, 2) -> 1
, c_22_0(1) -> 1
, c_23_0(1) -> 1
, c_39_0(1) -> 1}
8) { proper^#(__(X1, X2)) -> c_25(__^#(proper(X1), proper(X2)))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))
, __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))}
The usable rules for this path are the following:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(nil()) -> ok(nil())
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(tt()) -> ok(tt())
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(nil()) -> ok(nil())
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(tt()) -> ok(tt())
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))
, proper^#(__(X1, X2)) -> c_25(__^#(proper(X1), proper(X2)))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))
, __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [1] x1 + [1]
c_23(x1) = [1] x1 + [1]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [1]
c_25(x1) = [1] x1 + [1]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [1] x1 + [1]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{proper^#(__(X1, X2)) -> c_25(__^#(proper(X1), proper(X2)))}
and weakly orienting the rules
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{proper^#(__(X1, X2)) -> c_25(__^#(proper(X1), proper(X2)))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [1] x1 + [0]
c_23(x1) = [1] x1 + [1]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [9]
c_25(x1) = [1] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [1] x1 + [1]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))}
and weakly orienting the rules
{ proper^#(__(X1, X2)) -> c_25(__^#(proper(X1), proper(X2)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [8]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [8]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [1] x1 + [1]
c_23(x1) = [1] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [13]
c_25(x1) = [1] x1 + [1]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [1] x1 + [1]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
and weakly orienting the rules
{ __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))
, proper^#(__(X1, X2)) -> c_25(__^#(proper(X1), proper(X2)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [3]
nil() = [7]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [2]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [6]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [5]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [1] x1 + [0]
c_23(x1) = [1] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [13]
c_25(x1) = [1] x1 + [4]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [1] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))
, proper^#(__(X1, X2)) -> c_25(__^#(proper(X1), proper(X2)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))
, proper^#(__(X1, X2)) -> c_25(__^#(proper(X1), proper(X2)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ mark_0(2) -> 2
, nil_0() -> 2
, tt_0() -> 2
, a_0() -> 2
, e_0() -> 2
, i_0() -> 2
, o_0() -> 2
, u_0() -> 2
, ok_0(2) -> 2
, __^#_0(2, 2) -> 1
, c_22_0(1) -> 1
, c_23_0(1) -> 1
, proper^#_0(2) -> 1
, c_39_0(1) -> 1}
9) { proper^#(and(X1, X2)) -> c_27(and^#(proper(X1), proper(X2)))
, and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
The usable rules for this path are the following:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(nil()) -> ok(nil())
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(tt()) -> ok(tt())
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(nil()) -> ok(nil())
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(tt()) -> ok(tt())
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))
, proper^#(and(X1, X2)) -> c_27(and^#(proper(X1), proper(X2)))
, and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [8]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [1] x1 + [1]
proper^#(x1) = [1] x1 + [1]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [1] x1 + [15]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [1] x1 + [1]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{proper^#(and(X1, X2)) -> c_27(and^#(proper(X1), proper(X2)))}
and weakly orienting the rules
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{proper^#(and(X1, X2)) -> c_27(and^#(proper(X1), proper(X2)))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [4]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [1] x1 + [2]
proper^#(x1) = [1] x1 + [9]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [1] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [1] x1 + [1]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
and weakly orienting the rules
{ proper^#(and(X1, X2)) -> c_27(and^#(proper(X1), proper(X2)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [8]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [2]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [1] x1 + [0]
proper^#(x1) = [1] x1 + [9]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [1] x1 + [5]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [1] x1 + [1]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
and weakly orienting the rules
{ and^#(mark(X1), X2) -> c_24(and^#(X1, X2))
, proper^#(and(X1, X2)) -> c_27(and^#(proper(X1), proper(X2)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [8]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [1]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [1] x1 + [0]
proper^#(x1) = [1] x1 + [8]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [1] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [1] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))
, proper^#(and(X1, X2)) -> c_27(and^#(proper(X1), proper(X2)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))
, proper^#(and(X1, X2)) -> c_27(and^#(proper(X1), proper(X2)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ mark_0(2) -> 2
, nil_0() -> 2
, tt_0() -> 2
, a_0() -> 2
, e_0() -> 2
, i_0() -> 2
, o_0() -> 2
, u_0() -> 2
, ok_0(2) -> 2
, and^#_0(2, 2) -> 1
, c_24_0(1) -> 1
, proper^#_0(2) -> 1
, c_40_0(1) -> 1}
10)
{ proper^#(isNePal(X)) -> c_32(isNePal^#(proper(X)))
, isNePal^#(ok(X)) -> c_44(isNePal^#(X))}
The usable rules for this path are the following:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(nil()) -> ok(nil())
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(tt()) -> ok(tt())
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(nil()) -> ok(nil())
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(tt()) -> ok(tt())
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))
, proper^#(isNePal(X)) -> c_32(isNePal^#(proper(X)))
, isNePal^#(ok(X)) -> c_44(isNePal^#(X))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [2]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [8]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [1] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [1]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [1] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [1] x1 + [1]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{isNePal^#(ok(X)) -> c_44(isNePal^#(X))}
and weakly orienting the rules
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{isNePal^#(ok(X)) -> c_44(isNePal^#(X))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [4]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [1] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [1] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [1] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{proper^#(isNePal(X)) -> c_32(isNePal^#(proper(X)))}
and weakly orienting the rules
{ isNePal^#(ok(X)) -> c_44(isNePal^#(X))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{proper^#(isNePal(X)) -> c_32(isNePal^#(proper(X)))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [2]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [1] x1 + [1]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [13]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [1] x1 + [7]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [1] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
and weakly orienting the rules
{ proper^#(isNePal(X)) -> c_32(isNePal^#(proper(X)))
, isNePal^#(ok(X)) -> c_44(isNePal^#(X))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [8]
isList(x1) = [1] x1 + [3]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [4]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [1] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [13]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [1] x1 + [7]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [1] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, proper^#(isNePal(X)) -> c_32(isNePal^#(proper(X)))
, isNePal^#(ok(X)) -> c_44(isNePal^#(X))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, proper^#(isNePal(X)) -> c_32(isNePal^#(proper(X)))
, isNePal^#(ok(X)) -> c_44(isNePal^#(X))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ mark_0(3) -> 3
, mark_0(4) -> 3
, mark_0(6) -> 3
, mark_0(12) -> 3
, mark_0(13) -> 3
, mark_0(14) -> 3
, mark_0(15) -> 3
, mark_0(16) -> 3
, mark_0(18) -> 3
, nil_0() -> 4
, tt_0() -> 6
, a_0() -> 12
, e_0() -> 13
, i_0() -> 14
, o_0() -> 15
, u_0() -> 16
, ok_0(3) -> 18
, ok_0(4) -> 18
, ok_0(6) -> 18
, ok_0(12) -> 18
, ok_0(13) -> 18
, ok_0(14) -> 18
, ok_0(15) -> 18
, ok_0(16) -> 18
, ok_0(18) -> 18
, isNePal^#_0(3) -> 38
, isNePal^#_0(4) -> 38
, isNePal^#_0(6) -> 38
, isNePal^#_0(12) -> 38
, isNePal^#_0(13) -> 38
, isNePal^#_0(14) -> 38
, isNePal^#_0(15) -> 38
, isNePal^#_0(16) -> 38
, isNePal^#_0(18) -> 38
, proper^#_0(3) -> 51
, proper^#_0(4) -> 51
, proper^#_0(6) -> 51
, proper^#_0(12) -> 51
, proper^#_0(13) -> 51
, proper^#_0(14) -> 51
, proper^#_0(15) -> 51
, proper^#_0(16) -> 51
, proper^#_0(18) -> 51
, c_44_0(38) -> 38}
11)
{ proper^#(isQid(X)) -> c_31(isQid^#(proper(X)))
, isQid^#(ok(X)) -> c_43(isQid^#(X))}
The usable rules for this path are the following:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(nil()) -> ok(nil())
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(tt()) -> ok(tt())
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(nil()) -> ok(nil())
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(tt()) -> ok(tt())
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))
, proper^#(isQid(X)) -> c_31(isQid^#(proper(X)))
, isQid^#(ok(X)) -> c_43(isQid^#(X))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [2]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [8]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [1]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [1] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [1] x1 + [1]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{isQid^#(ok(X)) -> c_43(isQid^#(X))}
and weakly orienting the rules
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{isQid^#(ok(X)) -> c_43(isQid^#(X))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [4]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [1]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [1] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [1] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{proper^#(isQid(X)) -> c_31(isQid^#(proper(X)))}
and weakly orienting the rules
{ isQid^#(ok(X)) -> c_43(isQid^#(X))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{proper^#(isQid(X)) -> c_31(isQid^#(proper(X)))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [2]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [1] x1 + [1]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [13]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [1] x1 + [7]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [1] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
and weakly orienting the rules
{ proper^#(isQid(X)) -> c_31(isQid^#(proper(X)))
, isQid^#(ok(X)) -> c_43(isQid^#(X))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [0]
nil() = [10]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [8]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [1] x1 + [4]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [9]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [1] x1 + [1]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [1] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, proper^#(isQid(X)) -> c_31(isQid^#(proper(X)))
, isQid^#(ok(X)) -> c_43(isQid^#(X))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, proper^#(isQid(X)) -> c_31(isQid^#(proper(X)))
, isQid^#(ok(X)) -> c_43(isQid^#(X))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ mark_0(3) -> 3
, mark_0(4) -> 3
, mark_0(6) -> 3
, mark_0(12) -> 3
, mark_0(13) -> 3
, mark_0(14) -> 3
, mark_0(15) -> 3
, mark_0(16) -> 3
, mark_0(18) -> 3
, nil_0() -> 4
, tt_0() -> 6
, a_0() -> 12
, e_0() -> 13
, i_0() -> 14
, o_0() -> 15
, u_0() -> 16
, ok_0(3) -> 18
, ok_0(4) -> 18
, ok_0(6) -> 18
, ok_0(12) -> 18
, ok_0(13) -> 18
, ok_0(14) -> 18
, ok_0(15) -> 18
, ok_0(16) -> 18
, ok_0(18) -> 18
, isQid^#_0(3) -> 32
, isQid^#_0(4) -> 32
, isQid^#_0(6) -> 32
, isQid^#_0(12) -> 32
, isQid^#_0(13) -> 32
, isQid^#_0(14) -> 32
, isQid^#_0(15) -> 32
, isQid^#_0(16) -> 32
, isQid^#_0(18) -> 32
, proper^#_0(3) -> 51
, proper^#_0(4) -> 51
, proper^#_0(6) -> 51
, proper^#_0(12) -> 51
, proper^#_0(13) -> 51
, proper^#_0(14) -> 51
, proper^#_0(15) -> 51
, proper^#_0(16) -> 51
, proper^#_0(18) -> 51
, c_43_0(32) -> 32}
12)
{ proper^#(isPal(X)) -> c_33(isPal^#(proper(X)))
, isPal^#(ok(X)) -> c_45(isPal^#(X))}
The usable rules for this path are the following:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(nil()) -> ok(nil())
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(tt()) -> ok(tt())
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(nil()) -> ok(nil())
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(tt()) -> ok(tt())
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))
, proper^#(isPal(X)) -> c_33(isPal^#(proper(X)))
, isPal^#(ok(X)) -> c_45(isPal^#(X))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [2]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [8]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [1]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [1] x1 + [0]
isPal^#(x1) = [1] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [1] x1 + [1]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{isPal^#(ok(X)) -> c_45(isPal^#(X))}
and weakly orienting the rules
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{isPal^#(ok(X)) -> c_45(isPal^#(X))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [4]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [1]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [1] x1 + [15]
isPal^#(x1) = [1] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [1] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{proper^#(isPal(X)) -> c_33(isPal^#(proper(X)))}
and weakly orienting the rules
{ isPal^#(ok(X)) -> c_45(isPal^#(X))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{proper^#(isPal(X)) -> c_33(isPal^#(proper(X)))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [2]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [13]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [1] x1 + [7]
isPal^#(x1) = [1] x1 + [1]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [1] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
and weakly orienting the rules
{ proper^#(isPal(X)) -> c_33(isPal^#(proper(X)))
, isPal^#(ok(X)) -> c_45(isPal^#(X))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [3]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [4]
isNePal(x1) = [1] x1 + [8]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [4]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [8]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [1] x1 + [5]
isPal^#(x1) = [1] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [1] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, proper^#(isPal(X)) -> c_33(isPal^#(proper(X)))
, isPal^#(ok(X)) -> c_45(isPal^#(X))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, proper^#(isPal(X)) -> c_33(isPal^#(proper(X)))
, isPal^#(ok(X)) -> c_45(isPal^#(X))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ mark_0(3) -> 3
, mark_0(4) -> 3
, mark_0(6) -> 3
, mark_0(12) -> 3
, mark_0(13) -> 3
, mark_0(14) -> 3
, mark_0(15) -> 3
, mark_0(16) -> 3
, mark_0(18) -> 3
, nil_0() -> 4
, tt_0() -> 6
, a_0() -> 12
, e_0() -> 13
, i_0() -> 14
, o_0() -> 15
, u_0() -> 16
, ok_0(3) -> 18
, ok_0(4) -> 18
, ok_0(6) -> 18
, ok_0(12) -> 18
, ok_0(13) -> 18
, ok_0(14) -> 18
, ok_0(15) -> 18
, ok_0(16) -> 18
, ok_0(18) -> 18
, proper^#_0(3) -> 51
, proper^#_0(4) -> 51
, proper^#_0(6) -> 51
, proper^#_0(12) -> 51
, proper^#_0(13) -> 51
, proper^#_0(14) -> 51
, proper^#_0(15) -> 51
, proper^#_0(16) -> 51
, proper^#_0(18) -> 51
, isPal^#_0(3) -> 62
, isPal^#_0(4) -> 62
, isPal^#_0(6) -> 62
, isPal^#_0(12) -> 62
, isPal^#_0(13) -> 62
, isPal^#_0(14) -> 62
, isPal^#_0(15) -> 62
, isPal^#_0(16) -> 62
, isPal^#_0(18) -> 62
, c_45_0(62) -> 62}
13)
{proper^#(__(X1, X2)) -> c_25(__^#(proper(X1), proper(X2)))}
The usable rules for this path are the following:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(nil()) -> ok(nil())
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(tt()) -> ok(tt())
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(nil()) -> ok(nil())
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(tt()) -> ok(tt())
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))
, proper^#(__(X1, X2)) -> c_25(__^#(proper(X1), proper(X2)))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [2]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [1]
c_25(x1) = [1] x1 + [1]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{proper^#(__(X1, X2)) -> c_25(__^#(proper(X1), proper(X2)))}
and weakly orienting the rules
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{proper^#(__(X1, X2)) -> c_25(__^#(proper(X1), proper(X2)))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [7]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [9]
c_25(x1) = [1] x1 + [1]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
and weakly orienting the rules
{ proper^#(__(X1, X2)) -> c_25(__^#(proper(X1), proper(X2)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [0]
nil() = [5]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [1]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [1]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [2]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [13]
c_25(x1) = [1] x1 + [1]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, proper^#(__(X1, X2)) -> c_25(__^#(proper(X1), proper(X2)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, proper^#(__(X1, X2)) -> c_25(__^#(proper(X1), proper(X2)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ mark_0(3) -> 3
, mark_0(4) -> 3
, mark_0(6) -> 3
, mark_0(12) -> 3
, mark_0(13) -> 3
, mark_0(14) -> 3
, mark_0(15) -> 3
, mark_0(16) -> 3
, mark_0(18) -> 3
, nil_0() -> 4
, tt_0() -> 6
, a_0() -> 12
, e_0() -> 13
, i_0() -> 14
, o_0() -> 15
, u_0() -> 16
, ok_0(3) -> 18
, ok_0(4) -> 18
, ok_0(6) -> 18
, ok_0(12) -> 18
, ok_0(13) -> 18
, ok_0(14) -> 18
, ok_0(15) -> 18
, ok_0(16) -> 18
, ok_0(18) -> 18
, __^#_0(3, 3) -> 22
, __^#_0(3, 4) -> 22
, __^#_0(3, 6) -> 22
, __^#_0(3, 12) -> 22
, __^#_0(3, 13) -> 22
, __^#_0(3, 14) -> 22
, __^#_0(3, 15) -> 22
, __^#_0(3, 16) -> 22
, __^#_0(3, 18) -> 22
, __^#_0(4, 3) -> 22
, __^#_0(4, 4) -> 22
, __^#_0(4, 6) -> 22
, __^#_0(4, 12) -> 22
, __^#_0(4, 13) -> 22
, __^#_0(4, 14) -> 22
, __^#_0(4, 15) -> 22
, __^#_0(4, 16) -> 22
, __^#_0(4, 18) -> 22
, __^#_0(6, 3) -> 22
, __^#_0(6, 4) -> 22
, __^#_0(6, 6) -> 22
, __^#_0(6, 12) -> 22
, __^#_0(6, 13) -> 22
, __^#_0(6, 14) -> 22
, __^#_0(6, 15) -> 22
, __^#_0(6, 16) -> 22
, __^#_0(6, 18) -> 22
, __^#_0(12, 3) -> 22
, __^#_0(12, 4) -> 22
, __^#_0(12, 6) -> 22
, __^#_0(12, 12) -> 22
, __^#_0(12, 13) -> 22
, __^#_0(12, 14) -> 22
, __^#_0(12, 15) -> 22
, __^#_0(12, 16) -> 22
, __^#_0(12, 18) -> 22
, __^#_0(13, 3) -> 22
, __^#_0(13, 4) -> 22
, __^#_0(13, 6) -> 22
, __^#_0(13, 12) -> 22
, __^#_0(13, 13) -> 22
, __^#_0(13, 14) -> 22
, __^#_0(13, 15) -> 22
, __^#_0(13, 16) -> 22
, __^#_0(13, 18) -> 22
, __^#_0(14, 3) -> 22
, __^#_0(14, 4) -> 22
, __^#_0(14, 6) -> 22
, __^#_0(14, 12) -> 22
, __^#_0(14, 13) -> 22
, __^#_0(14, 14) -> 22
, __^#_0(14, 15) -> 22
, __^#_0(14, 16) -> 22
, __^#_0(14, 18) -> 22
, __^#_0(15, 3) -> 22
, __^#_0(15, 4) -> 22
, __^#_0(15, 6) -> 22
, __^#_0(15, 12) -> 22
, __^#_0(15, 13) -> 22
, __^#_0(15, 14) -> 22
, __^#_0(15, 15) -> 22
, __^#_0(15, 16) -> 22
, __^#_0(15, 18) -> 22
, __^#_0(16, 3) -> 22
, __^#_0(16, 4) -> 22
, __^#_0(16, 6) -> 22
, __^#_0(16, 12) -> 22
, __^#_0(16, 13) -> 22
, __^#_0(16, 14) -> 22
, __^#_0(16, 15) -> 22
, __^#_0(16, 16) -> 22
, __^#_0(16, 18) -> 22
, __^#_0(18, 3) -> 22
, __^#_0(18, 4) -> 22
, __^#_0(18, 6) -> 22
, __^#_0(18, 12) -> 22
, __^#_0(18, 13) -> 22
, __^#_0(18, 14) -> 22
, __^#_0(18, 15) -> 22
, __^#_0(18, 16) -> 22
, __^#_0(18, 18) -> 22
, proper^#_0(3) -> 51
, proper^#_0(4) -> 51
, proper^#_0(6) -> 51
, proper^#_0(12) -> 51
, proper^#_0(13) -> 51
, proper^#_0(14) -> 51
, proper^#_0(15) -> 51
, proper^#_0(16) -> 51
, proper^#_0(18) -> 51}
14)
{proper^#(and(X1, X2)) -> c_27(and^#(proper(X1), proper(X2)))}
The usable rules for this path are the following:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(nil()) -> ok(nil())
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(tt()) -> ok(tt())
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(nil()) -> ok(nil())
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(tt()) -> ok(tt())
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))
, proper^#(and(X1, X2)) -> c_27(and^#(proper(X1), proper(X2)))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [1]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [1]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [1] x1 + [1]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{proper^#(and(X1, X2)) -> c_27(and^#(proper(X1), proper(X2)))}
and weakly orienting the rules
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{proper^#(and(X1, X2)) -> c_27(and^#(proper(X1), proper(X2)))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [7]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [9]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [1] x1 + [1]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
and weakly orienting the rules
{ proper^#(and(X1, X2)) -> c_27(and^#(proper(X1), proper(X2)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [0]
nil() = [1]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [1]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [2]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [13]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [1] x1 + [1]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, proper^#(and(X1, X2)) -> c_27(and^#(proper(X1), proper(X2)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, proper^#(and(X1, X2)) -> c_27(and^#(proper(X1), proper(X2)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ mark_0(3) -> 3
, mark_0(4) -> 3
, mark_0(6) -> 3
, mark_0(12) -> 3
, mark_0(13) -> 3
, mark_0(14) -> 3
, mark_0(15) -> 3
, mark_0(16) -> 3
, mark_0(18) -> 3
, nil_0() -> 4
, tt_0() -> 6
, a_0() -> 12
, e_0() -> 13
, i_0() -> 14
, o_0() -> 15
, u_0() -> 16
, ok_0(3) -> 18
, ok_0(4) -> 18
, ok_0(6) -> 18
, ok_0(12) -> 18
, ok_0(13) -> 18
, ok_0(14) -> 18
, ok_0(15) -> 18
, ok_0(16) -> 18
, ok_0(18) -> 18
, and^#_0(3, 3) -> 30
, and^#_0(3, 4) -> 30
, and^#_0(3, 6) -> 30
, and^#_0(3, 12) -> 30
, and^#_0(3, 13) -> 30
, and^#_0(3, 14) -> 30
, and^#_0(3, 15) -> 30
, and^#_0(3, 16) -> 30
, and^#_0(3, 18) -> 30
, and^#_0(4, 3) -> 30
, and^#_0(4, 4) -> 30
, and^#_0(4, 6) -> 30
, and^#_0(4, 12) -> 30
, and^#_0(4, 13) -> 30
, and^#_0(4, 14) -> 30
, and^#_0(4, 15) -> 30
, and^#_0(4, 16) -> 30
, and^#_0(4, 18) -> 30
, and^#_0(6, 3) -> 30
, and^#_0(6, 4) -> 30
, and^#_0(6, 6) -> 30
, and^#_0(6, 12) -> 30
, and^#_0(6, 13) -> 30
, and^#_0(6, 14) -> 30
, and^#_0(6, 15) -> 30
, and^#_0(6, 16) -> 30
, and^#_0(6, 18) -> 30
, and^#_0(12, 3) -> 30
, and^#_0(12, 4) -> 30
, and^#_0(12, 6) -> 30
, and^#_0(12, 12) -> 30
, and^#_0(12, 13) -> 30
, and^#_0(12, 14) -> 30
, and^#_0(12, 15) -> 30
, and^#_0(12, 16) -> 30
, and^#_0(12, 18) -> 30
, and^#_0(13, 3) -> 30
, and^#_0(13, 4) -> 30
, and^#_0(13, 6) -> 30
, and^#_0(13, 12) -> 30
, and^#_0(13, 13) -> 30
, and^#_0(13, 14) -> 30
, and^#_0(13, 15) -> 30
, and^#_0(13, 16) -> 30
, and^#_0(13, 18) -> 30
, and^#_0(14, 3) -> 30
, and^#_0(14, 4) -> 30
, and^#_0(14, 6) -> 30
, and^#_0(14, 12) -> 30
, and^#_0(14, 13) -> 30
, and^#_0(14, 14) -> 30
, and^#_0(14, 15) -> 30
, and^#_0(14, 16) -> 30
, and^#_0(14, 18) -> 30
, and^#_0(15, 3) -> 30
, and^#_0(15, 4) -> 30
, and^#_0(15, 6) -> 30
, and^#_0(15, 12) -> 30
, and^#_0(15, 13) -> 30
, and^#_0(15, 14) -> 30
, and^#_0(15, 15) -> 30
, and^#_0(15, 16) -> 30
, and^#_0(15, 18) -> 30
, and^#_0(16, 3) -> 30
, and^#_0(16, 4) -> 30
, and^#_0(16, 6) -> 30
, and^#_0(16, 12) -> 30
, and^#_0(16, 13) -> 30
, and^#_0(16, 14) -> 30
, and^#_0(16, 15) -> 30
, and^#_0(16, 16) -> 30
, and^#_0(16, 18) -> 30
, and^#_0(18, 3) -> 30
, and^#_0(18, 4) -> 30
, and^#_0(18, 6) -> 30
, and^#_0(18, 12) -> 30
, and^#_0(18, 13) -> 30
, and^#_0(18, 14) -> 30
, and^#_0(18, 15) -> 30
, and^#_0(18, 16) -> 30
, and^#_0(18, 18) -> 30
, proper^#_0(3) -> 51
, proper^#_0(4) -> 51
, proper^#_0(6) -> 51
, proper^#_0(12) -> 51
, proper^#_0(13) -> 51
, proper^#_0(14) -> 51
, proper^#_0(15) -> 51
, proper^#_0(16) -> 51
, proper^#_0(18) -> 51}
15)
{proper^#(isPal(X)) -> c_33(isPal^#(proper(X)))}
The usable rules for this path are the following:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(nil()) -> ok(nil())
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(tt()) -> ok(tt())
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(nil()) -> ok(nil())
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(tt()) -> ok(tt())
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))
, proper^#(isPal(X)) -> c_33(isPal^#(proper(X)))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [3]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [8]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [1]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [1] x1 + [0]
isPal^#(x1) = [1] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{proper^#(isPal(X)) -> c_33(isPal^#(proper(X)))}
and weakly orienting the rules
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{proper^#(isPal(X)) -> c_33(isPal^#(proper(X)))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [8]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [9]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [1] x1 + [0]
isPal^#(x1) = [1] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
and weakly orienting the rules
{ proper^#(isPal(X)) -> c_33(isPal^#(proper(X)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [3]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [9]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [1] x1 + [8]
isPal^#(x1) = [1] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, proper^#(isPal(X)) -> c_33(isPal^#(proper(X)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, proper^#(isPal(X)) -> c_33(isPal^#(proper(X)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ mark_0(3) -> 3
, mark_0(4) -> 3
, mark_0(6) -> 3
, mark_0(12) -> 3
, mark_0(13) -> 3
, mark_0(14) -> 3
, mark_0(15) -> 3
, mark_0(16) -> 3
, mark_0(18) -> 3
, nil_0() -> 4
, tt_0() -> 6
, a_0() -> 12
, e_0() -> 13
, i_0() -> 14
, o_0() -> 15
, u_0() -> 16
, ok_0(3) -> 18
, ok_0(4) -> 18
, ok_0(6) -> 18
, ok_0(12) -> 18
, ok_0(13) -> 18
, ok_0(14) -> 18
, ok_0(15) -> 18
, ok_0(16) -> 18
, ok_0(18) -> 18
, proper^#_0(3) -> 51
, proper^#_0(4) -> 51
, proper^#_0(6) -> 51
, proper^#_0(12) -> 51
, proper^#_0(13) -> 51
, proper^#_0(14) -> 51
, proper^#_0(15) -> 51
, proper^#_0(16) -> 51
, proper^#_0(18) -> 51
, isPal^#_0(3) -> 62
, isPal^#_0(4) -> 62
, isPal^#_0(6) -> 62
, isPal^#_0(12) -> 62
, isPal^#_0(13) -> 62
, isPal^#_0(14) -> 62
, isPal^#_0(15) -> 62
, isPal^#_0(16) -> 62
, isPal^#_0(18) -> 62}
16)
{proper^#(isList(X)) -> c_29(isList^#(proper(X)))}
The usable rules for this path are the following:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(nil()) -> ok(nil())
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(tt()) -> ok(tt())
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(nil()) -> ok(nil())
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(tt()) -> ok(tt())
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))
, proper^#(isList(X)) -> c_29(isList^#(proper(X)))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [8]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [1]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [1] x1 + [8]
isList^#(x1) = [1] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{proper^#(isList(X)) -> c_29(isList^#(proper(X)))}
and weakly orienting the rules
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{proper^#(isList(X)) -> c_29(isList^#(proper(X)))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [8]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [9]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [1] x1 + [0]
isList^#(x1) = [1] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
and weakly orienting the rules
{ proper^#(isList(X)) -> c_29(isList^#(proper(X)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [5]
nil() = [7]
and(x1, x2) = [1] x1 + [1] x2 + [3]
tt() = [8]
isList(x1) = [1] x1 + [7]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [2]
isNePal(x1) = [1] x1 + [8]
isPal(x1) = [1] x1 + [0]
a() = [8]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [1] x1 + [0]
isList^#(x1) = [1] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, proper^#(isList(X)) -> c_29(isList^#(proper(X)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, proper^#(isList(X)) -> c_29(isList^#(proper(X)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ mark_0(3) -> 3
, mark_0(4) -> 3
, mark_0(6) -> 3
, mark_0(12) -> 3
, mark_0(13) -> 3
, mark_0(14) -> 3
, mark_0(15) -> 3
, mark_0(16) -> 3
, mark_0(18) -> 3
, nil_0() -> 4
, tt_0() -> 6
, a_0() -> 12
, e_0() -> 13
, i_0() -> 14
, o_0() -> 15
, u_0() -> 16
, ok_0(3) -> 18
, ok_0(4) -> 18
, ok_0(6) -> 18
, ok_0(12) -> 18
, ok_0(13) -> 18
, ok_0(14) -> 18
, ok_0(15) -> 18
, ok_0(16) -> 18
, ok_0(18) -> 18
, proper^#_0(3) -> 51
, proper^#_0(4) -> 51
, proper^#_0(6) -> 51
, proper^#_0(12) -> 51
, proper^#_0(13) -> 51
, proper^#_0(14) -> 51
, proper^#_0(15) -> 51
, proper^#_0(16) -> 51
, proper^#_0(18) -> 51
, isList^#_0(3) -> 57
, isList^#_0(4) -> 57
, isList^#_0(6) -> 57
, isList^#_0(12) -> 57
, isList^#_0(13) -> 57
, isList^#_0(14) -> 57
, isList^#_0(15) -> 57
, isList^#_0(16) -> 57
, isList^#_0(18) -> 57}
17)
{ proper^#(isList(X)) -> c_29(isList^#(proper(X)))
, isList^#(ok(X)) -> c_41(isList^#(X))}
The usable rules for this path are the following:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(nil()) -> ok(nil())
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(tt()) -> ok(tt())
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(nil()) -> ok(nil())
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(tt()) -> ok(tt())
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))
, proper^#(isList(X)) -> c_29(isList^#(proper(X)))
, isList^#(ok(X)) -> c_41(isList^#(X))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isList^#(ok(X)) -> c_41(isList^#(X))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isList^#(ok(X)) -> c_41(isList^#(X))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [2]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [1]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [1] x1 + [1]
isList^#(x1) = [1] x1 + [15]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [1] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{proper^#(isList(X)) -> c_29(isList^#(proper(X)))}
and weakly orienting the rules
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isList^#(ok(X)) -> c_41(isList^#(X))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{proper^#(isList(X)) -> c_29(isList^#(proper(X)))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [2]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [8]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [1] x1 + [0]
isList^#(x1) = [1] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [1] x1 + [1]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
and weakly orienting the rules
{ proper^#(isList(X)) -> c_29(isList^#(proper(X)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isList^#(ok(X)) -> c_41(isList^#(X))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [8]
nil() = [15]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [1]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [1] x1 + [0]
isList^#(x1) = [1] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [1] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, proper^#(isList(X)) -> c_29(isList^#(proper(X)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isList^#(ok(X)) -> c_41(isList^#(X))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, proper^#(isList(X)) -> c_29(isList^#(proper(X)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isList^#(ok(X)) -> c_41(isList^#(X))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ mark_0(3) -> 3
, mark_0(4) -> 3
, mark_0(6) -> 3
, mark_0(12) -> 3
, mark_0(13) -> 3
, mark_0(14) -> 3
, mark_0(15) -> 3
, mark_0(16) -> 3
, mark_0(18) -> 3
, nil_0() -> 4
, tt_0() -> 6
, a_0() -> 12
, e_0() -> 13
, i_0() -> 14
, o_0() -> 15
, u_0() -> 16
, ok_0(3) -> 18
, ok_0(4) -> 18
, ok_0(6) -> 18
, ok_0(12) -> 18
, ok_0(13) -> 18
, ok_0(14) -> 18
, ok_0(15) -> 18
, ok_0(16) -> 18
, ok_0(18) -> 18
, proper^#_0(3) -> 51
, proper^#_0(4) -> 51
, proper^#_0(6) -> 51
, proper^#_0(12) -> 51
, proper^#_0(13) -> 51
, proper^#_0(14) -> 51
, proper^#_0(15) -> 51
, proper^#_0(16) -> 51
, proper^#_0(18) -> 51
, isList^#_0(3) -> 57
, isList^#_0(4) -> 57
, isList^#_0(6) -> 57
, isList^#_0(12) -> 57
, isList^#_0(13) -> 57
, isList^#_0(14) -> 57
, isList^#_0(15) -> 57
, isList^#_0(16) -> 57
, isList^#_0(18) -> 57
, c_41_0(57) -> 57}
18)
{ proper^#(isNeList(X)) -> c_30(isNeList^#(proper(X)))
, isNeList^#(ok(X)) -> c_42(isNeList^#(X))}
The usable rules for this path are the following:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(nil()) -> ok(nil())
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(tt()) -> ok(tt())
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(nil()) -> ok(nil())
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(tt()) -> ok(tt())
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))
, proper^#(isNeList(X)) -> c_30(isNeList^#(proper(X)))
, isNeList^#(ok(X)) -> c_42(isNeList^#(X))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNeList^#(ok(X)) -> c_42(isNeList^#(X))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNeList^#(ok(X)) -> c_42(isNeList^#(X))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [2]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [8]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [1] x1 + [15]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [1]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [1] x1 + [1]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [1] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{proper^#(isNeList(X)) -> c_30(isNeList^#(proper(X)))}
and weakly orienting the rules
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNeList^#(ok(X)) -> c_42(isNeList^#(X))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{proper^#(isNeList(X)) -> c_30(isNeList^#(proper(X)))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [2]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [8]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [1] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [1] x1 + [1]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
and weakly orienting the rules
{ proper^#(isNeList(X)) -> c_30(isNeList^#(proper(X)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNeList^#(ok(X)) -> c_42(isNeList^#(X))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [0]
nil() = [2]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [8]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [7]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [8]
isPal(x1) = [1] x1 + [8]
a() = [0]
e() = [4]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [1] x1 + [1]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [1] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, proper^#(isNeList(X)) -> c_30(isNeList^#(proper(X)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNeList^#(ok(X)) -> c_42(isNeList^#(X))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, proper^#(isNeList(X)) -> c_30(isNeList^#(proper(X)))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNeList^#(ok(X)) -> c_42(isNeList^#(X))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ mark_0(3) -> 3
, mark_0(4) -> 3
, mark_0(6) -> 3
, mark_0(12) -> 3
, mark_0(13) -> 3
, mark_0(14) -> 3
, mark_0(15) -> 3
, mark_0(16) -> 3
, mark_0(18) -> 3
, nil_0() -> 4
, tt_0() -> 6
, a_0() -> 12
, e_0() -> 13
, i_0() -> 14
, o_0() -> 15
, u_0() -> 16
, ok_0(3) -> 18
, ok_0(4) -> 18
, ok_0(6) -> 18
, ok_0(12) -> 18
, ok_0(13) -> 18
, ok_0(14) -> 18
, ok_0(15) -> 18
, ok_0(16) -> 18
, ok_0(18) -> 18
, isNeList^#_0(3) -> 27
, isNeList^#_0(4) -> 27
, isNeList^#_0(6) -> 27
, isNeList^#_0(12) -> 27
, isNeList^#_0(13) -> 27
, isNeList^#_0(14) -> 27
, isNeList^#_0(15) -> 27
, isNeList^#_0(16) -> 27
, isNeList^#_0(18) -> 27
, proper^#_0(3) -> 51
, proper^#_0(4) -> 51
, proper^#_0(6) -> 51
, proper^#_0(12) -> 51
, proper^#_0(13) -> 51
, proper^#_0(14) -> 51
, proper^#_0(15) -> 51
, proper^#_0(16) -> 51
, proper^#_0(18) -> 51
, c_42_0(27) -> 27}
19)
{proper^#(isNeList(X)) -> c_30(isNeList^#(proper(X)))}
The usable rules for this path are the following:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(nil()) -> ok(nil())
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(tt()) -> ok(tt())
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(nil()) -> ok(nil())
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(tt()) -> ok(tt())
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))
, proper^#(isNeList(X)) -> c_30(isNeList^#(proper(X)))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, proper^#(isNeList(X)) -> c_30(isNeList^#(proper(X)))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, proper^#(isNeList(X)) -> c_30(isNeList^#(proper(X)))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [3]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [8]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [1] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
and weakly orienting the rules
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, proper^#(isNeList(X)) -> c_30(isNeList^#(proper(X)))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [9]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [1] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, proper^#(isNeList(X)) -> c_30(isNeList^#(proper(X)))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, proper^#(isNeList(X)) -> c_30(isNeList^#(proper(X)))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ mark_0(3) -> 3
, mark_0(4) -> 3
, mark_0(6) -> 3
, mark_0(12) -> 3
, mark_0(13) -> 3
, mark_0(14) -> 3
, mark_0(15) -> 3
, mark_0(16) -> 3
, mark_0(18) -> 3
, nil_0() -> 4
, tt_0() -> 6
, a_0() -> 12
, e_0() -> 13
, i_0() -> 14
, o_0() -> 15
, u_0() -> 16
, ok_0(3) -> 18
, ok_0(4) -> 18
, ok_0(6) -> 18
, ok_0(12) -> 18
, ok_0(13) -> 18
, ok_0(14) -> 18
, ok_0(15) -> 18
, ok_0(16) -> 18
, ok_0(18) -> 18
, isNeList^#_0(3) -> 27
, isNeList^#_0(4) -> 27
, isNeList^#_0(6) -> 27
, isNeList^#_0(12) -> 27
, isNeList^#_0(13) -> 27
, isNeList^#_0(14) -> 27
, isNeList^#_0(15) -> 27
, isNeList^#_0(16) -> 27
, isNeList^#_0(18) -> 27
, proper^#_0(3) -> 51
, proper^#_0(4) -> 51
, proper^#_0(6) -> 51
, proper^#_0(12) -> 51
, proper^#_0(13) -> 51
, proper^#_0(14) -> 51
, proper^#_0(15) -> 51
, proper^#_0(16) -> 51
, proper^#_0(18) -> 51}
20)
{proper^#(isQid(X)) -> c_31(isQid^#(proper(X)))}
The usable rules for this path are the following:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(nil()) -> ok(nil())
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(tt()) -> ok(tt())
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(nil()) -> ok(nil())
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(tt()) -> ok(tt())
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))
, proper^#(isQid(X)) -> c_31(isQid^#(proper(X)))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, proper^#(isQid(X)) -> c_31(isQid^#(proper(X)))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, proper^#(isQid(X)) -> c_31(isQid^#(proper(X)))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [3]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [8]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [9]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [1] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
and weakly orienting the rules
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, proper^#(isQid(X)) -> c_31(isQid^#(proper(X)))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [0]
nil() = [15]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [5]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [1] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, proper^#(isQid(X)) -> c_31(isQid^#(proper(X)))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, proper^#(isQid(X)) -> c_31(isQid^#(proper(X)))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ mark_0(3) -> 3
, mark_0(4) -> 3
, mark_0(6) -> 3
, mark_0(12) -> 3
, mark_0(13) -> 3
, mark_0(14) -> 3
, mark_0(15) -> 3
, mark_0(16) -> 3
, mark_0(18) -> 3
, nil_0() -> 4
, tt_0() -> 6
, a_0() -> 12
, e_0() -> 13
, i_0() -> 14
, o_0() -> 15
, u_0() -> 16
, ok_0(3) -> 18
, ok_0(4) -> 18
, ok_0(6) -> 18
, ok_0(12) -> 18
, ok_0(13) -> 18
, ok_0(14) -> 18
, ok_0(15) -> 18
, ok_0(16) -> 18
, ok_0(18) -> 18
, isQid^#_0(3) -> 32
, isQid^#_0(4) -> 32
, isQid^#_0(6) -> 32
, isQid^#_0(12) -> 32
, isQid^#_0(13) -> 32
, isQid^#_0(14) -> 32
, isQid^#_0(15) -> 32
, isQid^#_0(16) -> 32
, isQid^#_0(18) -> 32
, proper^#_0(3) -> 51
, proper^#_0(4) -> 51
, proper^#_0(6) -> 51
, proper^#_0(12) -> 51
, proper^#_0(13) -> 51
, proper^#_0(14) -> 51
, proper^#_0(15) -> 51
, proper^#_0(16) -> 51
, proper^#_0(18) -> 51}
21)
{proper^#(isNePal(X)) -> c_32(isNePal^#(proper(X)))}
The usable rules for this path are the following:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(nil()) -> ok(nil())
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(tt()) -> ok(tt())
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(nil()) -> ok(nil())
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(tt()) -> ok(tt())
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))
, proper^#(isNePal(X)) -> c_32(isNePal^#(proper(X)))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, proper^#(isNePal(X)) -> c_32(isNePal^#(proper(X)))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, proper^#(isNePal(X)) -> c_32(isNePal^#(proper(X)))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [3]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [8]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [1] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [9]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [1] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
and weakly orienting the rules
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, proper^#(isNePal(X)) -> c_32(isNePal^#(proper(X)))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [0]
nil() = [5]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [1] x1 + [15]
isQid(x1) = [1] x1 + [12]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [5]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [1] x1 + [1]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [1] x1 + [4]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [9]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [1] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, proper^#(isNePal(X)) -> c_32(isNePal^#(proper(X)))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ proper(__(X1, X2)) -> __(proper(X1), proper(X2))
, proper(and(X1, X2)) -> and(proper(X1), proper(X2))
, proper(isList(X)) -> isList(proper(X))
, proper(isNeList(X)) -> isNeList(proper(X))
, proper(isQid(X)) -> isQid(proper(X))
, proper(isNePal(X)) -> isNePal(proper(X))
, proper(isPal(X)) -> isPal(proper(X))
, __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, and(mark(X1), X2) -> mark(and(X1, X2))
, isNePal(ok(X)) -> ok(isNePal(X))}
Weak Rules:
{ proper(nil()) -> ok(nil())
, proper(tt()) -> ok(tt())
, proper(a()) -> ok(a())
, proper(e()) -> ok(e())
, proper(i()) -> ok(i())
, proper(o()) -> ok(o())
, proper(u()) -> ok(u())
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, and(ok(X1), ok(X2)) -> ok(and(X1, X2))
, proper^#(isNePal(X)) -> c_32(isNePal^#(proper(X)))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ mark_0(3) -> 3
, mark_0(4) -> 3
, mark_0(6) -> 3
, mark_0(12) -> 3
, mark_0(13) -> 3
, mark_0(14) -> 3
, mark_0(15) -> 3
, mark_0(16) -> 3
, mark_0(18) -> 3
, nil_0() -> 4
, tt_0() -> 6
, a_0() -> 12
, e_0() -> 13
, i_0() -> 14
, o_0() -> 15
, u_0() -> 16
, ok_0(3) -> 18
, ok_0(4) -> 18
, ok_0(6) -> 18
, ok_0(12) -> 18
, ok_0(13) -> 18
, ok_0(14) -> 18
, ok_0(15) -> 18
, ok_0(16) -> 18
, ok_0(18) -> 18
, isNePal^#_0(3) -> 38
, isNePal^#_0(4) -> 38
, isNePal^#_0(6) -> 38
, isNePal^#_0(12) -> 38
, isNePal^#_0(13) -> 38
, isNePal^#_0(14) -> 38
, isNePal^#_0(15) -> 38
, isNePal^#_0(16) -> 38
, isNePal^#_0(18) -> 38
, proper^#_0(3) -> 51
, proper^#_0(4) -> 51
, proper^#_0(6) -> 51
, proper^#_0(12) -> 51
, proper^#_0(13) -> 51
, proper^#_0(14) -> 51
, proper^#_0(15) -> 51
, proper^#_0(16) -> 51
, proper^#_0(18) -> 51}
22)
{ active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z)))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))
, __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))}
The usable rules for this path are the following:
{ __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z)))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))
, __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))}
Details:
We apply the weight gap principle, strictly orienting the rules
{active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z)))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z)))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [1]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [1] x1 + [1]
c_23(x1) = [1] x1 + [1]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [1] x1 + [1]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))}
and weakly orienting the rules
{active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z)))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [1]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [8]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [2]
c_0(x1) = [1] x1 + [2]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [1] x1 + [0]
c_23(x1) = [1] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [1] x1 + [1]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))}
and weakly orienting the rules
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))
, active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z)))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [1]
mark(x1) = [1] x1 + [8]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [1]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [3]
c_0(x1) = [1] x1 + [4]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [1] x1 + [1]
c_23(x1) = [1] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [1] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))}
Weak Rules:
{ __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))
, active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z)))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))}
Weak Rules:
{ __^#(X1, mark(X2)) -> c_23(__^#(X1, X2))
, __^#(mark(X1), X2) -> c_22(__^#(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, __^#(ok(X1), ok(X2)) -> c_39(__^#(X1, X2))
, active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z)))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ mark_0(3) -> 3
, mark_0(18) -> 3
, ok_0(3) -> 18
, ok_0(18) -> 18
, active^#_0(3) -> 20
, active^#_0(18) -> 20
, __^#_0(3, 3) -> 22
, __^#_0(3, 18) -> 22
, __^#_0(18, 3) -> 22
, __^#_0(18, 18) -> 22
, c_22_0(22) -> 22
, c_23_0(22) -> 22
, c_39_0(22) -> 22}
23)
{ active^#(isNePal(__(I, __(P, I)))) ->
c_11(and^#(isQid(I), isPal(P)))
, and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
The usable rules for this path are the following:
{ isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, active^#(isNePal(__(I, __(P, I)))) ->
c_11(and^#(isQid(I), isPal(P)))
, and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
Details:
We apply the weight gap principle, strictly orienting the rules
{and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [8]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [1] x1 + [1]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [1]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [1] x1 + [1]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [1] x1 + [1]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [1] x1 + [1]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active^#(isNePal(__(I, __(P, I)))) ->
c_11(and^#(isQid(I), isPal(P)))}
and weakly orienting the rules
{and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active^#(isNePal(__(I, __(P, I)))) ->
c_11(and^#(isQid(I), isPal(P)))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [5]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [1] x1 + [1]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [1] x1 + [1]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [11]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [1] x1 + [8]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [1] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [1] x1 + [10]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))}
and weakly orienting the rules
{ active^#(isNePal(__(I, __(P, I)))) ->
c_11(and^#(isQid(I), isPal(P)))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [4]
mark(x1) = [1] x1 + [4]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [1] x1 + [12]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [4]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [12]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [1] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [1] x1 + [3]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [1] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))}
Weak Rules:
{ and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))
, active^#(isNePal(__(I, __(P, I)))) ->
c_11(and^#(isQid(I), isPal(P)))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))}
Weak Rules:
{ and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))
, active^#(isNePal(__(I, __(P, I)))) ->
c_11(and^#(isQid(I), isPal(P)))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ mark_0(3) -> 3
, mark_0(18) -> 3
, ok_0(3) -> 18
, ok_0(18) -> 18
, active^#_0(3) -> 20
, active^#_0(18) -> 20
, and^#_0(3, 3) -> 30
, and^#_0(3, 18) -> 30
, and^#_0(18, 3) -> 30
, and^#_0(18, 18) -> 30
, c_24_0(30) -> 30
, c_40_0(30) -> 30}
24)
{ active^#(isNeList(__(V1, V2))) ->
c_9(and^#(isNeList(V1), isList(V2)))
, and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
The usable rules for this path are the following:
{ isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, active^#(isNeList(__(V1, V2))) ->
c_9(and^#(isNeList(V1), isList(V2)))
, and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
Details:
We apply the weight gap principle, strictly orienting the rules
{and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [8]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [1]
isNeList(x1) = [1] x1 + [1]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [1]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [1] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [1] x1 + [3]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [1] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active^#(isNeList(__(V1, V2))) ->
c_9(and^#(isNeList(V1), isList(V2)))}
and weakly orienting the rules
{and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active^#(isNeList(__(V1, V2))) ->
c_9(and^#(isNeList(V1), isList(V2)))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [9]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [1]
isNeList(x1) = [1] x1 + [1]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [8]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [1] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [1] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [1] x1 + [4]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))}
and weakly orienting the rules
{ active^#(isNeList(__(V1, V2))) ->
c_9(and^#(isNeList(V1), isList(V2)))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [11]
mark(x1) = [1] x1 + [10]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [7]
isNeList(x1) = [1] x1 + [5]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [10]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [9]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [4]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [1] x1 + [1]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [1] x1 + [10]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [1] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))}
Weak Rules:
{ and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))
, active^#(isNeList(__(V1, V2))) ->
c_9(and^#(isNeList(V1), isList(V2)))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))}
Weak Rules:
{ and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))
, active^#(isNeList(__(V1, V2))) ->
c_9(and^#(isNeList(V1), isList(V2)))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ mark_0(3) -> 3
, mark_0(18) -> 3
, ok_0(3) -> 18
, ok_0(18) -> 18
, active^#_0(3) -> 20
, active^#_0(18) -> 20
, and^#_0(3, 3) -> 30
, and^#_0(3, 18) -> 30
, and^#_0(18, 3) -> 30
, and^#_0(18, 18) -> 30
, c_24_0(30) -> 30
, c_40_0(30) -> 30}
25)
{ active^#(isNeList(__(V1, V2))) ->
c_8(and^#(isList(V1), isNeList(V2)))
, and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
The usable rules for this path are the following:
{ isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, active^#(isNeList(__(V1, V2))) ->
c_8(and^#(isList(V1), isNeList(V2)))
, and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
Details:
We apply the weight gap principle, strictly orienting the rules
{and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [8]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [1]
isNeList(x1) = [1] x1 + [1]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [1]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [1] x1 + [3]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [1] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active^#(isNeList(__(V1, V2))) ->
c_8(and^#(isList(V1), isNeList(V2)))}
and weakly orienting the rules
{and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active^#(isNeList(__(V1, V2))) ->
c_8(and^#(isList(V1), isNeList(V2)))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [9]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [1]
isNeList(x1) = [1] x1 + [1]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [8]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [1] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [1] x1 + [4]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))}
and weakly orienting the rules
{ active^#(isNeList(__(V1, V2))) ->
c_8(and^#(isList(V1), isNeList(V2)))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [14]
mark(x1) = [1] x1 + [8]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [7]
isNeList(x1) = [1] x1 + [3]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [10]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [4]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [1] x1 + [8]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [1] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))}
Weak Rules:
{ and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))
, active^#(isNeList(__(V1, V2))) ->
c_8(and^#(isList(V1), isNeList(V2)))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))}
Weak Rules:
{ and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))
, active^#(isNeList(__(V1, V2))) ->
c_8(and^#(isList(V1), isNeList(V2)))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ mark_0(3) -> 3
, mark_0(18) -> 3
, ok_0(3) -> 18
, ok_0(18) -> 18
, active^#_0(3) -> 20
, active^#_0(18) -> 20
, and^#_0(3, 3) -> 30
, and^#_0(3, 18) -> 30
, and^#_0(18, 3) -> 30
, and^#_0(18, 18) -> 30
, c_24_0(30) -> 30
, c_40_0(30) -> 30}
26)
{ active^#(isList(__(V1, V2))) ->
c_6(and^#(isList(V1), isList(V2)))
, and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
The usable rules for this path are the following:
{isList(ok(X)) -> ok(isList(X))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ isList(ok(X)) -> ok(isList(X))
, active^#(isList(__(V1, V2))) ->
c_6(and^#(isList(V1), isList(V2)))
, and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
Details:
We apply the weight gap principle, strictly orienting the rules
{and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [8]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [1]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
and^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [1] x1 + [1]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [1] x1 + [1]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{active^#(isList(__(V1, V2))) ->
c_6(and^#(isList(V1), isList(V2)))}
and weakly orienting the rules
{and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active^#(isList(__(V1, V2))) ->
c_6(and^#(isList(V1), isList(V2)))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [1]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [1]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [8]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [2]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [1] x1 + [1]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [1] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))}
and weakly orienting the rules
{ active^#(isList(__(V1, V2))) ->
c_6(and^#(isList(V1), isList(V2)))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [1]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [8]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [8]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [3]
and^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [1] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [1] x1 + [9]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules: {isList(ok(X)) -> ok(isList(X))}
Weak Rules:
{ and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))
, active^#(isList(__(V1, V2))) ->
c_6(and^#(isList(V1), isList(V2)))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules: {isList(ok(X)) -> ok(isList(X))}
Weak Rules:
{ and^#(ok(X1), ok(X2)) -> c_40(and^#(X1, X2))
, active^#(isList(__(V1, V2))) ->
c_6(and^#(isList(V1), isList(V2)))
, and^#(mark(X1), X2) -> c_24(and^#(X1, X2))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ mark_0(3) -> 3
, mark_0(18) -> 3
, ok_0(3) -> 18
, ok_0(18) -> 18
, active^#_0(3) -> 20
, active^#_0(18) -> 20
, and^#_0(3, 3) -> 30
, and^#_0(3, 18) -> 30
, and^#_0(18, 3) -> 30
, and^#_0(18, 18) -> 30
, c_24_0(30) -> 30
, c_40_0(30) -> 30}
27)
{active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z)))}
The usable rules for this path are the following:
{ __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))
, __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z)))}
Details:
We apply the weight gap principle, strictly orienting the rules
{active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z)))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z)))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [1]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{__(ok(X1), ok(X2)) -> ok(__(X1, X2))}
and weakly orienting the rules
{active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z)))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{__(ok(X1), ok(X2)) -> ok(__(X1, X2))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [1]
mark(x1) = [1] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [8]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [9]
c_0(x1) = [1] x1 + [0]
__^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))}
Weak Rules:
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z)))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ __(mark(X1), X2) -> mark(__(X1, X2))
, __(X1, mark(X2)) -> mark(__(X1, X2))}
Weak Rules:
{ __(ok(X1), ok(X2)) -> ok(__(X1, X2))
, active^#(__(__(X, Y), Z)) -> c_0(__^#(X, __(Y, Z)))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ mark_0(3) -> 3
, mark_0(18) -> 3
, ok_0(3) -> 18
, ok_0(18) -> 18
, active^#_0(3) -> 20
, active^#_0(18) -> 20
, __^#_0(3, 3) -> 22
, __^#_0(3, 18) -> 22
, __^#_0(18, 3) -> 22
, __^#_0(18, 18) -> 22}
28)
{active^#(isNePal(__(I, __(P, I)))) ->
c_11(and^#(isQid(I), isPal(P)))}
The usable rules for this path are the following:
{ isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))
, active^#(isNePal(__(I, __(P, I)))) ->
c_11(and^#(isQid(I), isPal(P)))}
Details:
We apply the weight gap principle, strictly orienting the rules
{active^#(isNePal(__(I, __(P, I)))) ->
c_11(and^#(isQid(I), isPal(P)))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active^#(isNePal(__(I, __(P, I)))) ->
c_11(and^#(isQid(I), isPal(P)))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [1] x1 + [1]
isNePal(x1) = [1] x1 + [4]
isPal(x1) = [1] x1 + [1]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [1] x1 + [1]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))}
Weak Rules:
{active^#(isNePal(__(I, __(P, I)))) ->
c_11(and^#(isQid(I), isPal(P)))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ isQid(ok(X)) -> ok(isQid(X))
, isPal(ok(X)) -> ok(isPal(X))}
Weak Rules:
{active^#(isNePal(__(I, __(P, I)))) ->
c_11(and^#(isQid(I), isPal(P)))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ ok_0(18) -> 18
, active^#_0(18) -> 20
, and^#_0(18, 18) -> 30}
29)
{active^#(isNeList(__(V1, V2))) ->
c_8(and^#(isList(V1), isNeList(V2)))}
The usable rules for this path are the following:
{ isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, active^#(isNeList(__(V1, V2))) ->
c_8(and^#(isList(V1), isNeList(V2)))}
Details:
We apply the weight gap principle, strictly orienting the rules
{active^#(isNeList(__(V1, V2))) ->
c_8(and^#(isList(V1), isNeList(V2)))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active^#(isNeList(__(V1, V2))) ->
c_8(and^#(isList(V1), isNeList(V2)))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [1]
isNeList(x1) = [1] x1 + [1]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [8]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [2]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [1] x1 + [1]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))}
Weak Rules:
{active^#(isNeList(__(V1, V2))) ->
c_8(and^#(isList(V1), isNeList(V2)))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))}
Weak Rules:
{active^#(isNeList(__(V1, V2))) ->
c_8(and^#(isList(V1), isNeList(V2)))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ ok_0(18) -> 18
, active^#_0(18) -> 20
, and^#_0(18, 18) -> 30}
30)
{active^#(isNeList(__(V1, V2))) ->
c_9(and^#(isNeList(V1), isList(V2)))}
The usable rules for this path are the following:
{ isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))
, active^#(isNeList(__(V1, V2))) ->
c_9(and^#(isNeList(V1), isList(V2)))}
Details:
We apply the weight gap principle, strictly orienting the rules
{active^#(isNeList(__(V1, V2))) ->
c_9(and^#(isNeList(V1), isList(V2)))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active^#(isNeList(__(V1, V2))) ->
c_9(and^#(isNeList(V1), isList(V2)))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [1]
isNeList(x1) = [1] x1 + [1]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [8]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [1] x1 + [1] x2 + [2]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [1] x1 + [1]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))}
Weak Rules:
{active^#(isNeList(__(V1, V2))) ->
c_9(and^#(isNeList(V1), isList(V2)))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ isList(ok(X)) -> ok(isList(X))
, isNeList(ok(X)) -> ok(isNeList(X))}
Weak Rules:
{active^#(isNeList(__(V1, V2))) ->
c_9(and^#(isNeList(V1), isList(V2)))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ ok_0(2) -> 2
, active^#_0(2) -> 1
, and^#_0(2, 2) -> 1}
31)
{active^#(isList(__(V1, V2))) ->
c_6(and^#(isList(V1), isList(V2)))}
The usable rules for this path are the following:
{isList(ok(X)) -> ok(isList(X))}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ isList(ok(X)) -> ok(isList(X))
, active^#(isList(__(V1, V2))) ->
c_6(and^#(isList(V1), isList(V2)))}
Details:
We apply the weight gap principle, strictly orienting the rules
{active^#(isList(__(V1, V2))) ->
c_6(and^#(isList(V1), isList(V2)))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active^#(isList(__(V1, V2))) ->
c_6(and^#(isList(V1), isList(V2)))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [1]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [8]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [1] x1 + [1]
and^#(x1, x2) = [1] x1 + [1] x2 + [4]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules: {isList(ok(X)) -> ok(isList(X))}
Weak Rules:
{active^#(isList(__(V1, V2))) ->
c_6(and^#(isList(V1), isList(V2)))}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules: {isList(ok(X)) -> ok(isList(X))}
Weak Rules:
{active^#(isList(__(V1, V2))) ->
c_6(and^#(isList(V1), isList(V2)))}
Details:
The problem is Match-bounded by 0.
The enriched problem is compatible with the following automaton:
{ ok_0(2) -> 2
, active^#_0(2) -> 1
, and^#_0(2, 2) -> 1}
32)
{ active^#(isList(V)) -> c_4(isNeList^#(V))
, isNeList^#(ok(X)) -> c_42(isNeList^#(X))}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {isNeList^#(ok(X)) -> c_42(isNeList^#(X))}
Weak Rules: {active^#(isList(V)) -> c_4(isNeList^#(V))}
Details:
We apply the weight gap principle, strictly orienting the rules
{isNeList^#(ok(X)) -> c_42(isNeList^#(X))}
and weakly orienting the rules
{active^#(isList(V)) -> c_4(isNeList^#(V))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{isNeList^#(ok(X)) -> c_42(isNeList^#(X))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [8]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [8]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [1] x1 + [1]
isNeList^#(x1) = [1] x1 + [1]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [1] x1 + [3]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules:
{ isNeList^#(ok(X)) -> c_42(isNeList^#(X))
, active^#(isList(V)) -> c_4(isNeList^#(V))}
Details:
The given problem does not contain any strict rules
33)
{active^#(__(X, nil())) -> c_1()}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {active^#(__(X, nil())) -> c_1()}
Weak Rules: {}
Details:
We apply the weight gap principle, strictly orienting the rules
{active^#(__(X, nil())) -> c_1()}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active^#(__(X, nil())) -> c_1()}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules: {active^#(__(X, nil())) -> c_1()}
Details:
The given problem does not contain any strict rules
34)
{ active^#(isNeList(V)) -> c_7(isQid^#(V))
, isQid^#(ok(X)) -> c_43(isQid^#(X))}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {isQid^#(ok(X)) -> c_43(isQid^#(X))}
Weak Rules: {active^#(isNeList(V)) -> c_7(isQid^#(V))}
Details:
We apply the weight gap principle, strictly orienting the rules
{isQid^#(ok(X)) -> c_43(isQid^#(X))}
and weakly orienting the rules
{active^#(isNeList(V)) -> c_7(isQid^#(V))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{isQid^#(ok(X)) -> c_43(isQid^#(X))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [8]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [8]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [1] x1 + [1]
isQid^#(x1) = [1] x1 + [1]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [1] x1 + [3]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules:
{ isQid^#(ok(X)) -> c_43(isQid^#(X))
, active^#(isNeList(V)) -> c_7(isQid^#(V))}
Details:
The given problem does not contain any strict rules
35)
{active^#(__(nil(), X)) -> c_2()}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {active^#(__(nil(), X)) -> c_2()}
Weak Rules: {}
Details:
We apply the weight gap principle, strictly orienting the rules
{active^#(__(nil(), X)) -> c_2()}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active^#(__(nil(), X)) -> c_2()}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [1] x1 + [1] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules: {active^#(__(nil(), X)) -> c_2()}
Details:
The given problem does not contain any strict rules
36)
{ active^#(isPal(V)) -> c_12(isNePal^#(V))
, isNePal^#(ok(X)) -> c_44(isNePal^#(X))}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {isNePal^#(ok(X)) -> c_44(isNePal^#(X))}
Weak Rules: {active^#(isPal(V)) -> c_12(isNePal^#(V))}
Details:
We apply the weight gap principle, strictly orienting the rules
{isNePal^#(ok(X)) -> c_44(isNePal^#(X))}
and weakly orienting the rules
{active^#(isPal(V)) -> c_12(isNePal^#(V))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{isNePal^#(ok(X)) -> c_44(isNePal^#(X))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [8]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [8]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [1]
isNePal^#(x1) = [1] x1 + [1]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [1] x1 + [3]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules:
{ isNePal^#(ok(X)) -> c_44(isNePal^#(X))
, active^#(isPal(V)) -> c_12(isNePal^#(V))}
Details:
The given problem does not contain any strict rules
37)
{active^#(and(tt(), X)) -> c_3()}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {active^#(and(tt(), X)) -> c_3()}
Weak Rules: {}
Details:
We apply the weight gap principle, strictly orienting the rules
{active^#(and(tt(), X)) -> c_3()}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active^#(and(tt(), X)) -> c_3()}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [1] x1 + [1] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules: {active^#(and(tt(), X)) -> c_3()}
Details:
The given problem does not contain any strict rules
38)
{ active^#(isNePal(V)) -> c_10(isQid^#(V))
, isQid^#(ok(X)) -> c_43(isQid^#(X))}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {isQid^#(ok(X)) -> c_43(isQid^#(X))}
Weak Rules: {active^#(isNePal(V)) -> c_10(isQid^#(V))}
Details:
We apply the weight gap principle, strictly orienting the rules
{isQid^#(ok(X)) -> c_43(isQid^#(X))}
and weakly orienting the rules
{active^#(isNePal(V)) -> c_10(isQid^#(V))}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{isQid^#(ok(X)) -> c_43(isQid^#(X))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [1] x1 + [8]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [8]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [1] x1 + [1]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [1]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [1] x1 + [3]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules:
{ isQid^#(ok(X)) -> c_43(isQid^#(X))
, active^#(isNePal(V)) -> c_10(isQid^#(V))}
Details:
The given problem does not contain any strict rules
39)
{active^#(isQid(a())) -> c_14()}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {active^#(isQid(a())) -> c_14()}
Weak Rules: {}
Details:
We apply the weight gap principle, strictly orienting the rules
{active^#(isQid(a())) -> c_14()}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active^#(isQid(a())) -> c_14()}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules: {active^#(isQid(a())) -> c_14()}
Details:
The given problem does not contain any strict rules
40)
{active^#(isList(V)) -> c_4(isNeList^#(V))}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {active^#(isList(V)) -> c_4(isNeList^#(V))}
Weak Rules: {}
Details:
We apply the weight gap principle, strictly orienting the rules
{active^#(isList(V)) -> c_4(isNeList^#(V))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active^#(isList(V)) -> c_4(isNeList^#(V))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [1] x1 + [0]
isNeList^#(x1) = [1] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules: {active^#(isList(V)) -> c_4(isNeList^#(V))}
Details:
The given problem does not contain any strict rules
41)
{active^#(isPal(nil())) -> c_13()}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {active^#(isPal(nil())) -> c_13()}
Weak Rules: {}
Details:
We apply the weight gap principle, strictly orienting the rules
{active^#(isPal(nil())) -> c_13()}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active^#(isPal(nil())) -> c_13()}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules: {active^#(isPal(nil())) -> c_13()}
Details:
The given problem does not contain any strict rules
42)
{active^#(isNeList(V)) -> c_7(isQid^#(V))}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {active^#(isNeList(V)) -> c_7(isQid^#(V))}
Weak Rules: {}
Details:
We apply the weight gap principle, strictly orienting the rules
{active^#(isNeList(V)) -> c_7(isQid^#(V))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active^#(isNeList(V)) -> c_7(isQid^#(V))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [1] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [1] x1 + [0]
isQid^#(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules: {active^#(isNeList(V)) -> c_7(isQid^#(V))}
Details:
The given problem does not contain any strict rules
43)
{active^#(isList(nil())) -> c_5()}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {active^#(isList(nil())) -> c_5()}
Weak Rules: {}
Details:
We apply the weight gap principle, strictly orienting the rules
{active^#(isList(nil())) -> c_5()}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active^#(isList(nil())) -> c_5()}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [1] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules: {active^#(isList(nil())) -> c_5()}
Details:
The given problem does not contain any strict rules
44)
{active^#(isNePal(V)) -> c_10(isQid^#(V))}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {active^#(isNePal(V)) -> c_10(isQid^#(V))}
Weak Rules: {}
Details:
We apply the weight gap principle, strictly orienting the rules
{active^#(isNePal(V)) -> c_10(isQid^#(V))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active^#(isNePal(V)) -> c_10(isQid^#(V))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [1] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [1] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [1] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules: {active^#(isNePal(V)) -> c_10(isQid^#(V))}
Details:
The given problem does not contain any strict rules
45)
{active^#(isPal(V)) -> c_12(isNePal^#(V))}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {active^#(isPal(V)) -> c_12(isNePal^#(V))}
Weak Rules: {}
Details:
We apply the weight gap principle, strictly orienting the rules
{active^#(isPal(V)) -> c_12(isNePal^#(V))}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active^#(isPal(V)) -> c_12(isNePal^#(V))}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [1] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [1] x1 + [0]
isNePal^#(x1) = [1] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules: {active^#(isPal(V)) -> c_12(isNePal^#(V))}
Details:
The given problem does not contain any strict rules
46)
{active^#(isQid(e())) -> c_15()}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {active^#(isQid(e())) -> c_15()}
Weak Rules: {}
Details:
We apply the weight gap principle, strictly orienting the rules
{active^#(isQid(e())) -> c_15()}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active^#(isQid(e())) -> c_15()}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules: {active^#(isQid(e())) -> c_15()}
Details:
The given problem does not contain any strict rules
47)
{active^#(isQid(i())) -> c_16()}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {active^#(isQid(i())) -> c_16()}
Weak Rules: {}
Details:
We apply the weight gap principle, strictly orienting the rules
{active^#(isQid(i())) -> c_16()}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active^#(isQid(i())) -> c_16()}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules: {active^#(isQid(i())) -> c_16()}
Details:
The given problem does not contain any strict rules
48)
{active^#(isQid(u())) -> c_18()}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {active^#(isQid(u())) -> c_18()}
Weak Rules: {}
Details:
We apply the weight gap principle, strictly orienting the rules
{active^#(isQid(u())) -> c_18()}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active^#(isQid(u())) -> c_18()}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules: {active^#(isQid(u())) -> c_18()}
Details:
The given problem does not contain any strict rules
49)
{active^#(isQid(o())) -> c_17()}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {active^#(isQid(o())) -> c_17()}
Weak Rules: {}
Details:
We apply the weight gap principle, strictly orienting the rules
{active^#(isQid(o())) -> c_17()}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{active^#(isQid(o())) -> c_17()}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [1] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [1] x1 + [1]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules: {active^#(isQid(o())) -> c_17()}
Details:
The given problem does not contain any strict rules
50)
{proper^#(nil()) -> c_26()}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {proper^#(nil()) -> c_26()}
Weak Rules: {}
Details:
We apply the weight gap principle, strictly orienting the rules
{proper^#(nil()) -> c_26()}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{proper^#(nil()) -> c_26()}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [1]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules: {proper^#(nil()) -> c_26()}
Details:
The given problem does not contain any strict rules
51)
{proper^#(e()) -> c_35()}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {proper^#(e()) -> c_35()}
Weak Rules: {}
Details:
We apply the weight gap principle, strictly orienting the rules
{proper^#(e()) -> c_35()}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{proper^#(e()) -> c_35()}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [1]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules: {proper^#(e()) -> c_35()}
Details:
The given problem does not contain any strict rules
52)
{proper^#(a()) -> c_34()}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {proper^#(a()) -> c_34()}
Weak Rules: {}
Details:
We apply the weight gap principle, strictly orienting the rules
{proper^#(a()) -> c_34()}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{proper^#(a()) -> c_34()}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [1]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules: {proper^#(a()) -> c_34()}
Details:
The given problem does not contain any strict rules
53)
{proper^#(o()) -> c_37()}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {proper^#(o()) -> c_37()}
Weak Rules: {}
Details:
We apply the weight gap principle, strictly orienting the rules
{proper^#(o()) -> c_37()}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{proper^#(o()) -> c_37()}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [1]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules: {proper^#(o()) -> c_37()}
Details:
The given problem does not contain any strict rules
54)
{proper^#(tt()) -> c_28()}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {proper^#(tt()) -> c_28()}
Weak Rules: {}
Details:
We apply the weight gap principle, strictly orienting the rules
{proper^#(tt()) -> c_28()}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{proper^#(tt()) -> c_28()}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [1]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules: {proper^#(tt()) -> c_28()}
Details:
The given problem does not contain any strict rules
55)
{proper^#(i()) -> c_36()}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {proper^#(i()) -> c_36()}
Weak Rules: {}
Details:
We apply the weight gap principle, strictly orienting the rules
{proper^#(i()) -> c_36()}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{proper^#(i()) -> c_36()}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [1]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules: {proper^#(i()) -> c_36()}
Details:
The given problem does not contain any strict rules
56)
{proper^#(u()) -> c_38()}
The usable rules for this path are empty.
We have oriented the usable rules with the following strongly linear interpretation:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [0] x1 + [0]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
We have applied the subprocessor on the resulting DP-problem:
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {proper^#(u()) -> c_38()}
Weak Rules: {}
Details:
We apply the weight gap principle, strictly orienting the rules
{proper^#(u()) -> c_38()}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{proper^#(u()) -> c_38()}
Details:
Interpretation Functions:
active(x1) = [0] x1 + [0]
__(x1, x2) = [0] x1 + [0] x2 + [0]
mark(x1) = [0] x1 + [0]
nil() = [0]
and(x1, x2) = [0] x1 + [0] x2 + [0]
tt() = [0]
isList(x1) = [0] x1 + [0]
isNeList(x1) = [0] x1 + [0]
isQid(x1) = [0] x1 + [0]
isNePal(x1) = [0] x1 + [0]
isPal(x1) = [0] x1 + [0]
a() = [0]
e() = [0]
i() = [0]
o() = [0]
u() = [0]
proper(x1) = [0] x1 + [0]
ok(x1) = [0] x1 + [0]
top(x1) = [0] x1 + [0]
active^#(x1) = [0] x1 + [0]
c_0(x1) = [0] x1 + [0]
__^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_1() = [0]
c_2() = [0]
c_3() = [0]
c_4(x1) = [0] x1 + [0]
isNeList^#(x1) = [0] x1 + [0]
c_5() = [0]
c_6(x1) = [0] x1 + [0]
and^#(x1, x2) = [0] x1 + [0] x2 + [0]
c_7(x1) = [0] x1 + [0]
isQid^#(x1) = [0] x1 + [0]
c_8(x1) = [0] x1 + [0]
c_9(x1) = [0] x1 + [0]
c_10(x1) = [0] x1 + [0]
c_11(x1) = [0] x1 + [0]
c_12(x1) = [0] x1 + [0]
isNePal^#(x1) = [0] x1 + [0]
c_13() = [0]
c_14() = [0]
c_15() = [0]
c_16() = [0]
c_17() = [0]
c_18() = [0]
c_19(x1) = [0] x1 + [0]
c_20(x1) = [0] x1 + [0]
c_21(x1) = [0] x1 + [0]
c_22(x1) = [0] x1 + [0]
c_23(x1) = [0] x1 + [0]
c_24(x1) = [0] x1 + [0]
proper^#(x1) = [1] x1 + [1]
c_25(x1) = [0] x1 + [0]
c_26() = [0]
c_27(x1) = [0] x1 + [0]
c_28() = [0]
c_29(x1) = [0] x1 + [0]
isList^#(x1) = [0] x1 + [0]
c_30(x1) = [0] x1 + [0]
c_31(x1) = [0] x1 + [0]
c_32(x1) = [0] x1 + [0]
c_33(x1) = [0] x1 + [0]
isPal^#(x1) = [0] x1 + [0]
c_34() = [0]
c_35() = [0]
c_36() = [0]
c_37() = [0]
c_38() = [0]
c_39(x1) = [0] x1 + [0]
c_40(x1) = [0] x1 + [0]
c_41(x1) = [0] x1 + [0]
c_42(x1) = [0] x1 + [0]
c_43(x1) = [0] x1 + [0]
c_44(x1) = [0] x1 + [0]
c_45(x1) = [0] x1 + [0]
top^#(x1) = [0] x1 + [0]
c_46(x1) = [0] x1 + [0]
c_47(x1) = [0] x1 + [0]
Finally we apply the subprocessor
'Empty TRS'
-----------
Answer: YES(?,O(1))
Input Problem: innermost DP runtime-complexity with respect to
Strict Rules: {}
Weak Rules: {proper^#(u()) -> c_38()}
Details:
The given problem does not contain any strict rules